在 Java 中表示和比较地理位置

Posted 2023-02-23

【中文标题】在 Java 中表示和比较地理位置

【英文标题】：Representing and comparing geographic locations in Java

【发布时间】：2015-04-25 10:03:04

【问题描述】：

我试图弄清楚如何表示地理位置，但我似乎无法在 SE 文档中找到任何相关的类。

我想做这样的事情：

Location locA = new Location(aa.aaaaaaa, bb.bbbbbbb); //lat/long coordinates
Location locB = .....
int meters = locA.distanceTo(locB);

理想情况下，我想要android Location 之类的东西，因为无论如何我的大部分位置数据都是从安卓设备发送的。据我了解，它包含有关准确性、纬度和速度的信息，这些信息很有用（但不是必需的）。

我知道如何自己实现它，但开源替代方案可以节省我一些时间。

如果我可以进行一些 IP/位置查找，那也将非常有帮助。但我想这完全是另一个问题。

【参考方案1】：

这是一种计算2点之间距离的方法，取自AndroidLocation类，稍作修改。看起来有点复杂——这是因为它使用Vincenty's formulae对WGS84椭球进行迭代计算：

/** distance between 2 geographic points on Earth, in km **/
public static double geoDistance(GeoPoint gp1, GeoPoint gp2) 
        // Based on http://www.ngs.noaa.gov/PUBS_LIB/inverse.pdf
        // using the "Inverse Formula" (section 4)

        int MAXITERS = 20;
        // Convert lat/long to radians
        double lat1 = gp1.getLat() * Math.PI / 180.0;
        double lat2 = gp2.getLat() * Math.PI / 180.0;
        double lon1 = gp1.getLon() * Math.PI / 180.0;
        double lon2 = gp2.getLon() * Math.PI / 180.0;

        double a = 6378.137; // WGS84 major axis
        double b = 6356.7523142; // WGS84 semi-major axis
        double f = (a - b) / a;
        double aSqMinusBSqOverBSq = (a * a - b * b) / (b * b);

        double L = lon2 - lon1;
        double A = 0.0;
        double U1 = Math.atan((1.0 - f) * Math.tan(lat1));
        double U2 = Math.atan((1.0 - f) * Math.tan(lat2));

        double cosU1 = Math.cos(U1);
        double cosU2 = Math.cos(U2);
        double sinU1 = Math.sin(U1);
        double sinU2 = Math.sin(U2);
        double cosU1cosU2 = cosU1 * cosU2;
        double sinU1sinU2 = sinU1 * sinU2;

        double sigma = 0.0;
        double deltaSigma = 0.0;
        double cosSqAlpha = 0.0;
        double cos2SM = 0.0;
        double cosSigma = 0.0;
        double sinSigma = 0.0;
        double cosLambda = 0.0;
        double sinLambda = 0.0;

        double lambda = L; // initial guess
        for (int iter = 0; iter < MAXITERS; iter++) 
            double lambdaOrig = lambda;
            cosLambda = Math.cos(lambda);
            sinLambda = Math.sin(lambda);
            double t1 = cosU2 * sinLambda;
            double t2 = cosU1 * sinU2 - sinU1 * cosU2 * cosLambda;
            double sinSqSigma = t1 * t1 + t2 * t2; // (14)
            sinSigma = Math.sqrt(sinSqSigma);
            cosSigma = sinU1sinU2 + cosU1cosU2 * cosLambda; // (15)
            sigma = Math.atan2(sinSigma, cosSigma); // (16)
            double sinAlpha = (sinSigma == 0) ? 0.0 :
                cosU1cosU2 * sinLambda / sinSigma; // (17)
            cosSqAlpha = 1.0 - sinAlpha * sinAlpha;
            cos2SM = (cosSqAlpha == 0) ? 0.0 :
                cosSigma - 2.0 * sinU1sinU2 / cosSqAlpha; // (18)

            double uSquared = cosSqAlpha * aSqMinusBSqOverBSq; // defn
            A = 1 + (uSquared / 16384.0) * // (3)
                (4096.0 + uSquared *
                 (-768 + uSquared * (320.0 - 175.0 * uSquared)));
            double B = (uSquared / 1024.0) * // (4)
                (256.0 + uSquared *
                 (-128.0 + uSquared * (74.0 - 47.0 * uSquared)));
            double C = (f / 16.0) *
                cosSqAlpha *
                (4.0 + f * (4.0 - 3.0 * cosSqAlpha)); // (10)
            double cos2SMSq = cos2SM * cos2SM;
            deltaSigma = B * sinSigma * // (6)
                (cos2SM + (B / 4.0) *
                 (cosSigma * (-1.0 + 2.0 * cos2SMSq) -
                  (B / 6.0) * cos2SM *
                  (-3.0 + 4.0 * sinSigma * sinSigma) *
                  (-3.0 + 4.0 * cos2SMSq)));

            lambda = L +
                (1.0 - C) * f * sinAlpha *
                (sigma + C * sinSigma *
                 (cos2SM + C * cosSigma *
                  (-1.0 + 2.0 * cos2SM * cos2SM))); // (11)

            double delta = (lambda - lambdaOrig) / lambda;
            if (Math.abs(delta) < 1.0e-12) 
                break;
            
        

        return b * A * (sigma - deltaSigma);
    

GeoPoint 类如下所示：

/**
 * Immutable point in geo coordinates (latitude, longitude) with accuracy in km
 */
public class GeoPoint 

    private final double lat;
    private final double lon;
    private final double accuracy;

    /**
     * New geo point without accuracy
     */
    public GeoPoint(double lat, double lon)
        this(lat, lon, -1d);
    

    /**
     * New geo point with specified accuracy
     * @param accuracy  accuracy in km
     */
    public GeoPoint(double lat, double lon, double accuracy)
        this.lat = lat;
        this.lon = lon;
        this.accuracy = accuracy < 0 ? -1d : accuracy;
    

    public double getLat()
        return this.lat;
    

    public double getLon()
        return this.lon;
    

    /**
     * @return accuracy in km. If < 0, accuracy is not defined
     */
    public double getAccuracy()
        return this.accuracy;
    

    @Override
    public String toString()
        return "lat = " + this.lat + "; lon = " + this.lon + (this.accuracy < 0 ? "" : ("; accuracy = " + this.accuracy));
    

    @Override
    public boolean equals(Object o) 
        if (this == o) return true;
        if (!(o instanceof GeoPoint) || o == null) return false;
        GeoPoint g = (GeoPoint) o;
        return g.lat == this.lat && g.lon == this.lon && g.accuracy == this.accuracy; 
    

【讨论】：

您好，感谢您的回答。我最终做了类似的事情，但使用了另一种计算距离的方法，如this answer 所示。并实现了我自己的 GeoLoc 类。它没有我想要的所有功能，但暂时就足够了。

这并没有花费太多时间，因为我已经准备好了代码。您提到的答案中的公式适用于短距离，因为它将地球视为球体，而不是椭球体。无论如何，不​​客气！