एंड्रॉइड: दो स्थानों के बीच दूरी की गणना करने के लिए सबसे अच्छी विधि

Question

मैंने इस विषय में थोड़ा सा शोध किया, लेकिन ऐसी कई राय हैं जो बिल्कुल स्पष्ट छवि नहीं देती हैं। मेरी समस्या यह है: मैं एंड्रॉइड के लिए एक जीपीएस-आधारित ऐप विकसित कर रहा हूं, जिसमें मैं एंड्रॉइड लोकेशन मैनेजर द्वारा निर्दिष्ट मेरे वर्तमान स्थान और वास्तविक समय में अन्य स्थान के बीच दूरी जानना चाहता हूं। मैंने हार्सिन फॉर्मूला, कोसाइन फॉर्मूला का एक कानून की कोशिश की, फिर मुझे पता चला कि एंड्रॉइड एसडीके मुझे एक साधारण काम देता है Location.distanceTo (स्थान) - मुझे यकीन नहीं है कि यह फ़ंक्शन किस विधि पर चलता है।
तो, बिंदु यह है कि, मेरे लिए उपयोग करने के लिए कोई अच्छा होगा, हालाँकि जब इन स्थानों के बीच वास्तविक दूरी ज्यादातर समय aprox से बड़ी नहीं होगी। 100-200 मीटर? शायद मुझे विन्सेंटी के फॉर्मूला की जांच करनी चाहिए? क्या यह वास्तव में धीमा है? क्या कोई मुझे बता सकता है कि मुझे क्या चुनना चाहिए?

Answer 1

दूरी का उपयोग न करें। दूरी का उपयोग करें जैसा कि यह लगता है कि आपके पास पहले से ही निर्देशांक हैं और आपको बस इस विधि के साथ आवश्यकता है: Location.distanceBetween() Javadoc

Answer 2

दूरी (स्थान) के लिए एंड्रॉइड स्रोत में देखकर, आप देख सकते हैं कि परिणाम "उलटा" पर आधारित है भूगणित के फॉर्मूला ":

कौन सा "Inverse Formula" (भाग 4)

इसके अलावा, दो तरीकों distanceTo और distanceBetween समान ही अंतर्निहित विधि का उपयोग का उपयोग कर पर आधारित है। उनके पास इनपुट/आउटपुट के वैकल्पिक रूप हैं।

पूर्णता के लिए, इस गणना का पूरा स्रोत नीचे शामिल है, लेकिन मैं आपको अपने लिए एंड्रॉइड.लोकेशन में स्थान श्रेणी देखने के लिए प्रोत्साहित करता हूं। (पुनश्च: मैं एंड्रॉयड गणना की सत्यता की जांच नहीं की थी। यह एक अच्छा व्यायाम होगा!)

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