Die Distanz zwischen zwei Breitengrad-Längengrad-Punkten berechnen? (Haversine-Formel)

Question

Wie berechne ich die Entfernung zwischen zwei Punkten, die durch Breiten- und Längengrad angegeben sind?

Zur Klarstellung möchte ich die Entfernung in Kilometern; die Punkte verwenden das WGS84-System und ich möchte die relativen Genauigkeiten der verfügbaren Methoden verstehen.

Answer 1

Dieser Link könnte Ihnen helfen, da er die Verwendung der Haversine-Formel zur Berechnung der Entfernung beschreibt.

Auszug:

Dieses Skript [in Javascript] berechnet Großkreisentfernungen zwischen den beiden Punkten - das heißt, die kürzeste Entfernung über die Erdoberfläche - unter Verwendung der 'Haversine'-Formel.

function getDistanceFromLatLonInKm(lat1,lon1,lat2,lon2) {
  var R = 6371; // Radius der Erde in km
  var dLat = deg2rad(lat2-lat1);  // deg2rad unten
  var dLon = deg2rad(lon2-lon1); 
  var a = 
    Math.sin(dLat/2) * Math.sin(dLat/2) +
    Math.cos(deg2rad(lat1)) * Math.cos(deg2rad(lat2)) * 
    Math.sin(dLon/2) * Math.sin(dLon/2)
    ; 
  var c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a)); 
  var d = R * c; // Entfernung in km
  return d;
}

function deg2rad(deg) {
  return deg * (Math.PI/180)
}

Answer 2

Ich musste viele Entfernungen zwischen den Punkten für mein Projekt berechnen, also habe ich versucht, den Code zu optimieren, den ich hier gefunden habe. Im Durchschnitt läuft meine neue Implementierung in verschiedenen Browsern 2 Mal schneller als die am meisten hochgestimmte Antwort.

function distance(lat1, lon1, lat2, lon2) {
  const r = 6371; // km
  const p = Math.PI / 180;

  const a = 0.5 - Math.cos((lat2 - lat1) * p) / 2
                + Math.cos(lat1 * p) * Math.cos(lat2 * p) *
                  (1 - Math.cos((lon2 - lon1) * p)) / 2;

  return 2 * r * Math.asin(Math.sqrt(a));
}

Sie können mit meinem jsPerf spielen und die Ergebnisse hier sehen.

Kürzlich musste ich das Gleiche in Python machen, also hier ist eine Python-Implementierung:

from math import cos, asin, sqrt, pi

def distance(lat1, lon1, lat2, lon2):
    r = 6371 # km
    p = pi / 180

    a = 0.5 - cos((lat2-lat1)*p)/2 + cos(lat1*p) * cos(lat2*p) * (1-cos((lon2-lon1)*p))/2
    return 2 * r * asin(sqrt(a))

Und der Vollständigkeit halber: Haversine auf Wikipedia.

Answer 3

Hier ist eine C# Implementierung:

static class DistanceAlgorithm
{
    const double PIx = 3.141592653589793;
    const double RADIUS = 6378.16;

    /// 
    /// Konvertiert Grad in Radiant um
    /// 
    /// Grad
    /// Der Äquivalent in Radianten
    public static double Radians(double x)
    {
        return x * PIx / 180;
    }

    /// 
    /// Berechnet die Entfernung zwischen zwei Orten.
    /// 
    /// 
    /// 
    /// 
    /// 
    /// 
    public static double DistanceBetweenPlaces(
        double lon1,
        double lat1,
        double lon2,
        double lat2)
    {
        double dlon = Radians(lon2 - lon1);
        double dlat = Radians(lat2 - lat1);

        double a = (Math.Sin(dlat / 2) * Math.Sin(dlat / 2)) + Math.Cos(Radians(lat1)) * Math.Cos(Radians(lat2)) * (Math.Sin(dlon / 2) * Math.Sin(dlon / 2));
        double angle = 2 * Math.Atan2(Math.Sqrt(a), Math.Sqrt(1 - a));
        return angle * RADIUS;
    }

}

Answer 4

Hier ist eine Java-Implementierung der Haversine-Formel.

public final static double AVERAGE_RADIUS_OF_EARTH_KM = 6371;
public int calculateDistanceInKilometer(double userLat, double userLng,
  double venueLat, double venueLng) {

    double latDistance = Math.toRadians(userLat - venueLat);
    double lngDistance = Math.toRadians(userLng - venueLng);

    double a = Math.sin(latDistance / 2) * Math.sin(latDistance / 2)
      + Math.cos(Math.toRadians(userLat)) * Math.cos(Math.toRadians(venueLat))
      * Math.sin(lngDistance / 2) * Math.sin(lngDistance / 2);

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

    return (int) (Math.round(AVERAGE_RADIUS_OF_EARTH_KM * c));
}

Beachten Sie, dass hier die Antwort auf den nächsten km gerundet wird.

Answer 5

Vielen Dank für all dies. Ich habe den folgenden Code in meiner Objective-C iPhone-App verwendet:

const double PIx = 3,141592653589793;
const double RADIO = 6371; // Durchschnittlicher Radius der Erde in km

double convertToRadians(double val) {

   return val * PIx / 180;
}

-(double)KilometerZwischenOrt1:(CLLocationCoordinate2D) ort1 undOrt2:(CLLocationCoordinate2D) ort2 {

        double dlon = convertToRadians(ort2.longitude - ort1.longitude);
        double dlat = convertToRadians(ort2.latitude - ort1.latitude);

        double a = ( pow(sin(dlat / 2), 2) + cos(convertToRadians(ort1.latitude))) * cos(convertToRadians(ort2.latitude)) * pow(sin(dlon / 2), 2);
        double winkel = 2 * asin(sqrt(a));

        return winkel * RADIO;
}

Latitude und Longitude sind in Dezimalzahlen angegeben. Ich habe min() für den asin() Aufruf nicht verwendet, da die Entfernungen, die ich benutze, so klein sind, dass es nicht erforderlich ist.

Es gab falsche Antworten, bis ich die Werte in Radian umgewandelt habe - jetzt sind sie fast gleich wie die Werte, die aus der Apple Map-App erhalten werden :-)

Zusätzliches Update:

Wenn Sie iOS4 oder neuer verwenden, bietet Apple einige Methoden, um dies zu tun, sodass die gleiche Funktionalität mit folgendem Code erreicht werden würde:

-(double)KilometerZwischenOrt1:(CLLocationCoordinate2D) ort1 undOrt2:(CLLocationCoordinate2D) ort2 {

    MKMapPoint  start, finish;

    start = MKMapPointForCoordinate(ort1);
    finish = MKMapPointForCoordinate(ort2);

    return MKMetersBetweenMapPoints(start, finish) / 1000;
}