Android：計算兩個位置之間距離的最佳方法

Question

我在這個主題中進行了一些研究，但也有很多意見不能給出清晰的圖像。我的問題是這樣的：我正在開發一個基於gps的Android應用程序，至於我想知道我的當前位置由Androids LocationManager指定的位置和其他位置之間的距離。我嘗試了Haversine公式，一個餘弦定律公式，然後我發現Android SDK給了我一個簡單的函數Location.distanceTo（Location） - 我不確定這個函數運行在什麼方法上。
所以，重點是，如果在大多數情況下這些位置之間的實際距離不會大於aprox，那麼這對我來說是很好用的。 100-200M？也許我應該檢查Vincenty的公式？真的很慢嗎？有人可以解釋我應該選擇什麼？

Answer 1

請勿使用distanceTo。使用distanceBetween方法，因爲它聽起來像你已經有了座標，這就是你需要的這個方法：Location.distanceBetween() Javadoc

Answer 2

尋找distanceTo（Location）的Android源代碼，你可以看到結果是基於「Inverse式」大地測量：

其是基於使用"Inverse Formula"（第4節）

此外，這兩種方法distanceTo和distanceBetween使用相同的基本方法。他們只有其他形式的輸入/輸出。

爲了完整起見，本計算的完整源代碼包含在下面，但我鼓勵您自己查看android.location中的Location類。 （P.S.我沒有檢查Android計算的正確性，這將是一個很好的練習！）

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; 
     } 
    } 
}