मैं जावा में दो अक्षांश + देशांतर बिंदुओं के आधार पर दूरी को मापने और बाध्यकारी बॉक्स कैसे बना सकता हूं?

Question

मैं दो अलग-अलग बिंदुओं के बीच की दूरी ढूंढना चाहता हूं। यह मुझे महान सर्कल दूरी के साथ पूरा किया जा सकता है। http://www.meridianworlddata.com/Distance-calculation.asp

एक बार आदेश बिंदु चारों ओर एक बॉक्स बनाने के लिए किया है, एक बिंदु और दूरी मुझे लगता है कि दूरी उत्तर बिंदु मिल चाहते हैं, और कहा कि दूरी पूर्व के साथ।

Answer 1

हमें बहुत अधिक स्थितित्मक डेटा प्लॉट करने के लिए OpenMap का उपयोग करके कुछ सफलता मिली है। LatLonPoint कक्षा है जिसमें दूरी सहित कुछ बुनियादी कार्यक्षमताएं हैं।

Answer 2

एक त्वरित Google खोज GeoTools बदल जाती है, जिसकी संभावना है कि आप किस तरह के कार्यों की तलाश कर रहे हैं।

Answer 3

यहां Haversine सूत्र का जावा कार्यान्वयन है। मैं इसे एक परियोजना में लेट/लम्बाई के बीच मील की दूरी की गणना करने के लिए उपयोग करता हूं।

public static double distFrom(double lat1, double lng1, double lat2, double lng2) { 
    double earthRadius = 3958.75; // miles (or 6371.0 kilometers) 
    double dLat = Math.toRadians(lat2-lat1); 
    double dLng = Math.toRadians(lng2-lng1); 
    double sindLat = Math.sin(dLat/2); 
    double sindLng = Math.sin(dLng/2); 
    double a = Math.pow(sindLat, 2) + Math.pow(sindLng, 2) 
      * Math.cos(Math.toRadians(lat1)) * Math.cos(Math.toRadians(lat2)); 
    double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a)); 
    double dist = earthRadius * c; 

    return dist; 
    } 

Answer 4

या आप SimpleLatLng का उपयोग कर सकते हैं। अपाचे 2.0 लाइसेंस प्राप्त और एक उत्पादन प्रणाली में उपयोग किया जाता है जिसे मैं जानता हूं: मेरा।

लघु कहानी:

मैं एक साधारण भू पुस्तकालय के लिए खोज रहा था और एक मेरी जरूरतों फिट करने के लिए नहीं मिल सका। और जो हर एप्लिकेशन में बार-बार इन छोटे भौगोलिक उपकरणों को लिखना और परीक्षण करना और डिबग करना चाहते हैं? एक बेहतर तरीका होना चाहिए!

तो SimpleLatLng अक्षांश-देशांतर डेटा को स्टोर करने, दूरी की गणना करने और आकार की सीमाएं बनाने के तरीके के रूप में पैदा हुआ था।

मुझे पता है कि मैं मूल पोस्टर की मदद करने में बहुत देर हो चुकी हूं, लेकिन मेरा लक्ष्य उन लोगों की मदद करना है जो इस प्रश्न को खोज में ढूंढते हैं। मुझे कुछ लोग इसका इस्तेमाल करना पसंद करेंगे और इस छोटी हल्के उपयोगिता के परीक्षण और दृष्टि में योगदान देंगे।

Answer 5

आप Java Geodesy Library for GPS का उपयोग कर सकते हैं, यह Vincenty's formulae का उपयोग करता है जो पृथ्वी की सतह वक्रता का खाता लेता है।

कार्यान्वयन इस प्रकार है:

import org.gavaghan.geodesy.*; 
... 
GeodeticCalculator geoCalc = new GeodeticCalculator(); 
Ellipsoid reference = Ellipsoid.WGS84; 
GlobalPosition pointA = new GlobalPosition(latitude, longitude, 0.0); 
GlobalPosition userPos = new GlobalPosition(userLat, userLon, 0.0); 
double distance = geoCalc.calculateGeodeticCurve(reference, userPos, pointA).getEllipsoidalDistance(); 

जिसके परिणामस्वरूप दूरी मीटर में है।

Answer 6

एक और अधिक सटीक दूरी (0.5mm) आप भी Vincenty सन्निकटन उपयोग कर सकते हैं:

/** 
* Calculates geodetic distance between two points specified by latitude/longitude using Vincenty inverse formula 
* for ellipsoids 
* 
* @param lat1 
*   first point latitude in decimal degrees 
* @param lon1 
*   first point longitude in decimal degrees 
* @param lat2 
*   second point latitude in decimal degrees 
* @param lon2 
*   second point longitude in decimal degrees 
* @returns distance in meters between points with 5.10<sup>-4</sup> precision 
* @see <a href="http://www.movable-type.co.uk/scripts/latlong-vincenty.html">Originally posted here</a> 
*/ 
public static double distVincenty(double lat1, double lon1, double lat2, double lon2) { 
    double a = 6378137, b = 6356752.314245, f = 1/298.257223563; // WGS-84 ellipsoid params 
    double L = Math.toRadians(lon2 - lon1); 
    double U1 = Math.atan((1 - f) * Math.tan(Math.toRadians(lat1))); 
    double U2 = Math.atan((1 - f) * Math.tan(Math.toRadians(lat2))); 
    double sinU1 = Math.sin(U1), cosU1 = Math.cos(U1); 
    double sinU2 = Math.sin(U2), cosU2 = Math.cos(U2); 

    double sinLambda, cosLambda, sinSigma, cosSigma, sigma, sinAlpha, cosSqAlpha, cos2SigmaM; 
    double lambda = L, lambdaP, iterLimit = 100; 
    do { 
     sinLambda = Math.sin(lambda); 
     cosLambda = Math.cos(lambda); 
     sinSigma = Math.sqrt((cosU2 * sinLambda) * (cosU2 * sinLambda) 
       + (cosU1 * sinU2 - sinU1 * cosU2 * cosLambda) * (cosU1 * sinU2 - sinU1 * cosU2 * cosLambda)); 
     if (sinSigma == 0) 
      return 0; // co-incident points 
     cosSigma = sinU1 * sinU2 + cosU1 * cosU2 * cosLambda; 
     sigma = Math.atan2(sinSigma, cosSigma); 
     sinAlpha = cosU1 * cosU2 * sinLambda/sinSigma; 
     cosSqAlpha = 1 - sinAlpha * sinAlpha; 
     cos2SigmaM = cosSigma - 2 * sinU1 * sinU2/cosSqAlpha; 
     if (Double.isNaN(cos2SigmaM)) 
      cos2SigmaM = 0; // equatorial line: cosSqAlpha=0 (§6) 
     double C = f/16 * cosSqAlpha * (4 + f * (4 - 3 * cosSqAlpha)); 
     lambdaP = lambda; 
     lambda = L + (1 - C) * f * sinAlpha 
       * (sigma + C * sinSigma * (cos2SigmaM + C * cosSigma * (-1 + 2 * cos2SigmaM * cos2SigmaM))); 
    } while (Math.abs(lambda - lambdaP) > 1e-12 && --iterLimit > 0); 

    if (iterLimit == 0) 
     return Double.NaN; // formula failed to converge 

    double uSq = cosSqAlpha * (a * a - b * b)/(b * b); 
    double A = 1 + uSq/16384 * (4096 + uSq * (-768 + uSq * (320 - 175 * uSq))); 
    double B = uSq/1024 * (256 + uSq * (-128 + uSq * (74 - 47 * uSq))); 
    double deltaSigma = B 
      * sinSigma 
      * (cos2SigmaM + B 
        /4 
        * (cosSigma * (-1 + 2 * cos2SigmaM * cos2SigmaM) - B/6 * cos2SigmaM 
          * (-3 + 4 * sinSigma * sinSigma) * (-3 + 4 * cos2SigmaM * cos2SigmaM))); 
    double dist = b * A * (sigma - deltaSigma); 

    return dist; 
} 

इस कोड को स्वतंत्र रूप से http://www.movable-type.co.uk/scripts/latlong-vincenty.html

Answer 7

सही Haversine दूरी सूत्र से अनुकूलित किया गया था ....

public static double HaverSineDistance(double lat1, double lng1, double lat2, double lng2) 
{ 
    // mHager 08-12-2012 
    // http://en.wikipedia.org/wiki/Haversine_formula 
    // Implementation 

    // convert to radians 
    lat1 = Math.toRadians(lat1); 
    lng1 = Math.toRadians(lng1); 
    lat2 = Math.toRadians(lat2); 
    lng2 = Math.toRadians(lng2); 

    double dlon = lng2 - lng1; 
    double dlat = lat2 - lat1; 

    double a = Math.pow((Math.sin(dlat/2)),2) + Math.cos(lat1) * Math.cos(lat2) * Math.pow(Math.sin(dlon/2),2); 

    double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a)); 

    return EARTH_RADIUS * c; 
} 

Answer 8

आसानी से दूरी खोजने के लिए पोस्टगिस फ़ंक्शन का उपयोग करें ..

यहाँ

लिंक

http://postgis.refractions.net/docs/using_postgis_dbmanagement.html

Answer 9

मैं आम तौर पर Mapping Toolbox साथ MATLAB का उपयोग करें, और उसके बाद मेरे जावा में कोड MATLAB Builder JA. का उपयोग कर यह मेरे जीवन बहुत आसान बना देता है का उपयोग करें। अधिकांश विद्यालयों में यह मुफ्त छात्र पहुंच के लिए है, आप इसे आजमा सकते हैं (या अपने काम को पाने के लिए परीक्षण संस्करण प्राप्त करें)।

Answer 10

http://www.movable-type.co.uk/scripts/latlong.html

public static Double distanceBetweenTwoLocationsInKm(Double latitudeOne, Double longitudeOne, Double latitudeTwo, Double longitudeTwo) { 
     if (latitudeOne == null || latitudeTwo == null || longitudeOne == null || longitudeTwo == null) { 
      return null; 
     } 

     Double earthRadius = 6371.0; 
     Double diffBetweenLatitudeRadians = Math.toRadians(latitudeTwo - latitudeOne); 
     Double diffBetweenLongitudeRadians = Math.toRadians(longitudeTwo - longitudeOne); 
     Double latitudeOneInRadians = Math.toRadians(latitudeOne); 
     Double latitudeTwoInRadians = Math.toRadians(latitudeTwo); 
     Double a = Math.sin(diffBetweenLatitudeRadians/2) * Math.sin(diffBetweenLatitudeRadians/2) + Math.cos(latitudeOneInRadians) * Math.cos(latitudeTwoInRadians) * Math.sin(diffBetweenLongitudeRadians/2) 
       * Math.sin(diffBetweenLongitudeRadians/2); 
     Double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a)); 
     return (earthRadius * c); 
    } 

Answer 11

मैं जानता हूँ कि बहुत-से उत्तर देखते हैं कि, लेकिन इस विषय पर कुछ शोध करने में, मैंने पाया है कि सबसे जवाब यहां Haversine सूत्र का उपयोग करें, लेकिन Vincenty सूत्र वास्तव में अधिक सटीक है। एक पोस्ट था जो जावास्क्रिप्ट संस्करण से गणना को अनुकूलित करता था, लेकिन यह बहुत ही कमजोर है। मुझे एक संस्करण मिला जो बेहतर है क्योंकि:

1. इसमें एक खुला लाइसेंस भी है।
2. यह ओओपी सिद्धांतों का उपयोग करता है।
3. आपके द्वारा उपयोग किए जाने वाले एलीपसॉइड को चुनने के लिए इसमें अधिक लचीलापन है।
4. इसमें भविष्य में विभिन्न गणनाओं की अनुमति देने के लिए और अधिक विधियां हैं।
5. यह अच्छी तरह से प्रलेखित है।

VincentyDistanceCalculator

Answer 12

यह विधि आपको किमी में भौगोलिक स्थान पर बीच की दूरी को खोजने में मदद मिलेगी।

private double getDist(double lat1, double lon1, double lat2, double lon2) 
{ 
    int R = 6373; // radius of the earth in kilometres 
    double lat1rad = Math.toRadians(lat1); 
    double lat2rad = Math.toRadians(lat2); 
    double deltaLat = Math.toRadians(lat2-lat1); 
    double deltaLon = Math.toRadians(lon2-lon1); 

    double a = Math.sin(deltaLat/2) * Math.sin(deltaLat/2) + 
      Math.cos(lat1rad) * Math.cos(lat2rad) * 
      Math.sin(deltaLon/2) * Math.sin(deltaLon/2); 
    double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a)); 

    double d = R * c; 
    return d; 
}