Uzyskiwanie odległości między dwoma punktami na podstawie szerokości / długości geograficznej

157

Próbowałem zaimplementować tę formułę: http://andrew.hedges.name/experiments/haversine/ Aplet działa dobrze dla dwóch punktów, które testuję:

wprowadź opis obrazu tutaj

Jednak mój kod nie działa.

from math import sin, cos, sqrt, atan2

R = 6373.0

lat1 = 52.2296756
lon1 = 21.0122287
lat2 = 52.406374
lon2 = 16.9251681

dlon = lon2 - lon1
dlat = lat2 - lat1
a = (sin(dlat/2))**2 + cos(lat1) * cos(lat2) * (sin(dlon/2))**2
c = 2 * atan2(sqrt(a), sqrt(1-a))
distance = R * c

print "Result", distance
print "Should be", 278.546

Zwracana odległość to 5447,05546147 . Czemu?

gwaramadze
źródło

Odpowiedzi:

206

Edycja: Tak jak uwaga, jeśli potrzebujesz tylko szybkiego i łatwego sposobu na znalezienie odległości między dwoma punktami, zdecydowanie zalecam skorzystanie z podejścia opisanego w odpowiedzi Kurta poniżej zamiast ponownego wdrażania Haversine - uzasadnienie znajdziesz w jego poście.

Ta odpowiedź skupia się tylko na odpowiedzi na konkretny błąd, który napotkał OP.


Dzieje się tak, ponieważ w Pythonie wszystkie funkcje trygonometryczne używają radianów , a nie stopni.

Możesz albo ręcznie przekonwertować liczby na radiany, albo użyć radiansfunkcji z modułu matematycznego:

from math import sin, cos, sqrt, atan2, radians

# approximate radius of earth in km
R = 6373.0

lat1 = radians(52.2296756)
lon1 = radians(21.0122287)
lat2 = radians(52.406374)
lon2 = radians(16.9251681)

dlon = lon2 - lon1
dlat = lat2 - lat1

a = sin(dlat / 2)**2 + cos(lat1) * cos(lat2) * sin(dlon / 2)**2
c = 2 * atan2(sqrt(a), sqrt(1 - a))

distance = R * c

print("Result:", distance)
print("Should be:", 278.546, "km")

Odległość zwraca teraz poprawną wartość 278.545589351km.

Michael0x2a
źródło
13
jest to prawdą w każdym języku programowania, a także w rachunku różniczkowym. używanie stopni jest wyjątkiem i jest używane tylko w ludzkiej mowie.
bluesmoon
11
Słowem, ta formuła wymaga, aby wszystkie stopnie były dodatnie. radians(abs(52.123))powinien załatwić sprawę ...
Richard Dunn
1
Czy na pewno wszystkie stopnie (kąty?) Są dodatnie? Myślę, że to źle. Rozważ, czy lat1, lon1 = 10, 10 (stopnie) i lat2, lon2 = -10, -10 (stopnie). Dodając abs () wokół stopni, odległość wyniesie zero, co jest nieprawidłowe. Być może chciałeś wziąć bezwzględną wartość dlon i / lub dlat, ale jeśli spojrzysz na dlon, wartości dlat w obliczeniu a, sinus jest funkcją parzystą, a cosinus do kwadratu jest funkcją parzystą, więc nie robię tego widzę też jakąkolwiek korzyść z przyjmowania wartości bezwzględnej dlat lub dlon.
Dave LeCompte
238

Aktualizacja: 04/2018: Zwróć uwagę, że odległość Vincenty jest przestarzała od wersji GeoPy 1.13 - zamiast tego należy użyć geopy.distance.distance ()!


Powyższe odpowiedzi opierają się na wzorze Haversine'a , który zakłada, że ​​ziemia jest kulą, co powoduje błędy do około 0,5% (zgodnie z help(geopy.distance)). Odległość Vincenty'ego wykorzystuje dokładniejsze modele elipsoidalne, takie jak WGS-84 i jest wdrażana w geopii . Na przykład,

import geopy.distance

coords_1 = (52.2296756, 21.0122287)
coords_2 = (52.406374, 16.9251681)

print geopy.distance.vincenty(coords_1, coords_2).km

wydrukuje odległość w 279.352901604kilometrach przy użyciu domyślnej elipsoidy WGS-84. (Możesz także wybrać .milesjedną z kilku innych jednostek odległości).

Kurt Peek
źródło
1
Dzięki. Czy możesz zaktualizować swoją odpowiedź o współrzędne, które podałem w pytaniu zamiast Newport i Cleveland. Zapewni lepsze zrozumienie przyszłym czytelnikom.
gwaramadze
1
Arbitralne lokalizacje Newport i Cleveland pochodzą z przykładowej dokumentacji geopolitycznej na liście PyPI: pypi.python.org/pypi/geopy
Jason Parham
Musiałem zmodyfikować odpowiedź Kurta Peeka na to: Wymagana kapitalizacja:print geopy.distance.VincentyDistance(coords_1, coords_2).km 279.352901604
Jim
4
Prawdopodobnie powinieneś użyć geopy.distance.distance(…)w kodzie, który jest aliasem obecnie najlepszej (= najdokładniejszej) formuły odległości. (Obecnie Vincenty.)
narodziny
10
Korzystanie z geopy.distance.vincenty w wynikach geopy-1.18.1: Vincenty jest przestarzały i zostanie usunięty w geopy 2.0. Zamiast tego użyj geopy.distance.geodesic(lub wartości domyślnej geopy.distance.distance), która jest dokładniejsza i zawsze zbiega.
juanmah
88

Osobom (takim jak ja) przyjeżdżającym tutaj przez wyszukiwarkę i szukającym rozwiązania działającego po wyjęciu z pudełka, polecam instalację mpu. Zainstaluj go przez pip install mpu --useri użyj go w ten sposób, aby uzyskać odległość haversine :

import mpu

# Point one
lat1 = 52.2296756
lon1 = 21.0122287

# Point two
lat2 = 52.406374
lon2 = 16.9251681

# What you were looking for
dist = mpu.haversine_distance((lat1, lon1), (lat2, lon2))
print(dist)  # gives 278.45817507541943.

Pakiet alternatywny to gpxpy.

Jeśli nie chcesz zależności, możesz użyć:

import math


def distance(origin, destination):
    """
    Calculate the Haversine distance.

    Parameters
    ----------
    origin : tuple of float
        (lat, long)
    destination : tuple of float
        (lat, long)

    Returns
    -------
    distance_in_km : float

    Examples
    --------
    >>> origin = (48.1372, 11.5756)  # Munich
    >>> destination = (52.5186, 13.4083)  # Berlin
    >>> round(distance(origin, destination), 1)
    504.2
    """
    lat1, lon1 = origin
    lat2, lon2 = destination
    radius = 6371  # km

    dlat = math.radians(lat2 - lat1)
    dlon = math.radians(lon2 - lon1)
    a = (math.sin(dlat / 2) * math.sin(dlat / 2) +
         math.cos(math.radians(lat1)) * math.cos(math.radians(lat2)) *
         math.sin(dlon / 2) * math.sin(dlon / 2))
    c = 2 * math.atan2(math.sqrt(a), math.sqrt(1 - a))
    d = radius * c

    return d


if __name__ == '__main__':
    import doctest
    doctest.testmod()

Inny pakiet alternatywny to [haversine][1]

from haversine import haversine, Unit

lyon = (45.7597, 4.8422) # (lat, lon)
paris = (48.8567, 2.3508)

haversine(lyon, paris)
>> 392.2172595594006  # in kilometers

haversine(lyon, paris, unit=Unit.MILES)
>> 243.71201856934454  # in miles

# you can also use the string abbreviation for units:
haversine(lyon, paris, unit='mi')
>> 243.71201856934454  # in miles

haversine(lyon, paris, unit=Unit.NAUTICAL_MILES)
>> 211.78037755311516  # in nautical miles

Twierdzą, że mają optymalizację wydajności dla odległości między wszystkimi punktami w dwóch wektorach

from haversine import haversine_vector, Unit

lyon = (45.7597, 4.8422) # (lat, lon)
paris = (48.8567, 2.3508)
new_york = (40.7033962, -74.2351462)

haversine_vector([lyon, lyon], [paris, new_york], Unit.KILOMETERS)

>> array([ 392.21725956, 6163.43638211])
Martin Thoma
źródło
Czy istnieje sposób na zmianę podanego Highetu jednego z punktów?
yovel cohen
Możesz po prostu dodać różnicę wysokości do odległości. Nie zrobiłbym tego jednak.
Martin Thoma
16

Doszedłem do znacznie prostszego i solidnego rozwiązania, które korzysta geodesicz geopypakietu, ponieważ prawdopodobnie i tak będziesz go używać w swoim projekcie, więc nie jest wymagana dodatkowa instalacja pakietu.

Oto moje rozwiązanie:

from geopy.distance import geodesic


origin = (30.172705, 31.526725)  # (latitude, longitude) don't confuse
dist = (30.288281, 31.732326)

print(geodesic(origin, dist).meters)  # 23576.805481751613
print(geodesic(origin, dist).kilometers)  # 23.576805481751613
print(geodesic(origin, dist).miles)  # 14.64994773134371

geopy

Ramy M. Mousa
źródło
5
import numpy as np


def Haversine(lat1,lon1,lat2,lon2, **kwarg):
    """
    This uses the ‘haversine’ formula to calculate the great-circle distance between two points – that is, 
    the shortest distance over the earth’s surface – giving an ‘as-the-crow-flies’ distance between the points 
    (ignoring any hills they fly over, of course!).
    Haversine
    formula:    a = sin²(Δφ/2) + cos φ1 ⋅ cos φ2 ⋅ sin²(Δλ/2)
    c = 2 ⋅ atan2( √a, √(1−a) )
    d = R ⋅ c
    where   φ is latitude, λ is longitude, R is earth’s radius (mean radius = 6,371km);
    note that angles need to be in radians to pass to trig functions!
    """
    R = 6371.0088
    lat1,lon1,lat2,lon2 = map(np.radians, [lat1,lon1,lat2,lon2])

    dlat = lat2 - lat1
    dlon = lon2 - lon1
    a = np.sin(dlat/2)**2 + np.cos(lat1) * np.cos(lat2) * np.sin(dlon/2) **2
    c = 2 * np.arctan2(a**0.5, (1-a)**0.5)
    d = R * c
    return round(d,4)
Sudhirln92
źródło
0

Istnieje wiele sposobów obliczenia odległości na podstawie współrzędnych, tj. Szerokości i długości geograficznej

Zainstaluj i zaimportuj

from geopy import distance
from math import sin, cos, sqrt, atan2, radians
from sklearn.neighbors import DistanceMetric
import osrm
import numpy as np

Zdefiniuj współrzędne

lat1, lon1, lat2, lon2, R = 20.9467,72.9520, 21.1702, 72.8311, 6373.0
coordinates_from = [lat1, lon1]
coordinates_to = [lat2, lon2]

Używanie haversine

dlon = radians(lon2) - radians(lon1)
dlat = radians(lat2) - radians(lat1)
    
a = sin(dlat / 2)**2 + cos(lat1) * cos(lat2) * sin(dlon / 2)**2
c = 2 * atan2(sqrt(a), sqrt(1 - a))
    
distance_haversine_formula = R * c
print('distance using haversine formula: ', distance_haversine_formula)

Używanie haversine ze sklearn

dist = DistanceMetric.get_metric('haversine')
    
X = [[radians(lat1), radians(lon1)], [radians(lat2), radians(lon2)]]
distance_sklearn = R * dist.pairwise(X)
print('distance using sklearn: ', np.array(distance_sklearn).item(1))

Korzystanie z OSRM

osrm_client = osrm.Client(host='http://router.project-osrm.org')
coordinates_osrm = [[lon1, lat1], [lon2, lat2]] # note that order is lon, lat
    
osrm_response = osrm_client.route(coordinates=coordinates_osrm, overview=osrm.overview.full)
dist_osrm = osrm_response.get('routes')[0].get('distance')/1000 # in km
print('distance using OSRM: ', dist_osrm)

Korzystanie z geopy

distance_geopy = distance.distance(coordinates_from, coordinates_to).km
print('distance using geopy: ', distance_geopy)
    
distance_geopy_great_circle = distance.great_circle(coordinates_from, coordinates_to).km 
print('distance using geopy great circle: ', distance_geopy_great_circle)

Wynik

distance using haversine formula:  26.07547017310917
distance using sklearn:  27.847882224769783
distance using OSRM:  33.091699999999996
distance using geopy:  27.7528030550408
distance using geopy great circle:  27.839182219511834
Patel Romil
źródło