使用谷歌地图和用户自定义函数获取不同距离

Question

我想要以米/公里为单位获取两纬度之间的距离。所以我使用下面的函数。它给了我不同的结果比谷歌地图。

你能帮我解决我的问题吗？我不明白什么是问题？

代码

float[] results = {0}; 

    android.location.Location.distanceBetween(lat1, lon1, lat2, lon2, results); 

当前纬度=23.012281666666663 当前经度=72.51798333333333

目的地纬度=23.1120487 目的地纬度=72.5766759

它给出了这样的结果= 12579.679在计，而在谷歌地图它给出这样的结果=17.9公里

我不明白为什么这两给出了不同的结果。

Answer 1

此图解释了为什么你得到12.5和17.6公里

---

---

要计算行驶距离（17.6公里），您需要使用directions API

Answer 2

您可以使用此2功能找到距离

* 注： *如果你不能正确地获得距离，然后尝试设置于我而言万VAR为1，因为我成倍的增加LAT与1E6长的值，因此必须与它分开。

public double calcdist() { 
      int MILLION = 1000000; 
      int EARTH_RADIUS_KM = 6371; 

      double lat1 = la1/MILLION; 
      double lon1 = lo1/MILLION; 
      double lat2 = la2/MILLION; 
      double lon2 = lo2/MILLION; 

      double lat1Rad = Math.toRadians(lat1); 
      double lat2Rad = Math.toRadians(lat2); 
      double deltaLonRad = Math.toRadians(lon2 - lon1); 

      double dist = Math 
        .acos(Math.sin(lat1Rad) * Math.sin(lat2Rad) + Math.cos(lat1Rad) 
          * Math.cos(lat2Rad) * Math.cos(deltaLonRad)) 
        * EARTH_RADIUS_KM; 
      return dist; 

     } 

和

private float round(float dist, int i) { 
     float p1 = (float) Math.pow(10, i); 
     dist = dist * p1; 
     float tmp = Math.round(dist); 
     return (float) tmp/p1; 
    } 

然后用它们作为

float tempdist = (float) calcdist(); 
dist = round(tempdist, 2); 

Answer 3

嘿，我在这里找到一个源代码，以防万一人表示，将通过陆路返回正确的距离移动。我没有尝试过，但你可以尝试告诉我它是否真的有效。 GPSSample.java

我不知道你是如何传递的纬度 - 龙Values..Please试试这个全样本代码一次。

和代码编写在android.location.Location.java为此如下..如果您希望可以直接在您的应用程序中使用它。

private static void computeDistanceAndBearing(double lat1, 
        double lon1, double lat2, double lon2, float[] results) { 
       // 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 
       lat1 *= Math.PI/180.0; 
       lat2 *= Math.PI/180.0; 
       lon1 *= Math.PI/180.0; 
       lon2 *= Math.PI/180.0; 

       double a = 6378137.0; // WGS84 major axis 
       double b = 6356752.3142; // 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; 
        } 
       } 

       float distance = (float) (b * A * (sigma - deltaSigma)); 
      results[0] = distance; 
      if (results.length > 1) { 
       float initialBearing = (float) Math.atan2(
         cosU2 * sinLambda, cosU1 * sinU2 - sinU1 * cosU2 
           * cosLambda); 
       initialBearing *= 180.0/Math.PI; 
       results[1] = initialBearing; 
       if (results.length > 2) { 
        float finalBearing = (float) Math.atan2(cosU1 
          * sinLambda, -sinU1 * cosU2 + cosU1 * sinU2 
          * cosLambda); 
        finalBearing *= 180.0/Math.PI; 
        results[2] = finalBearing; 
       } 
      } 
     }