Comment convertir la latitude ou la longitude en mètres?

Si j'ai une lecture de latitude ou de longitude au format NMEA standard, existe-t-il un moyen / une formule simple pour convertir cette lecture en mètres, que je peux ensuite implémenter en Java (J9)?

Edit: Ok il semble que ce que je veux faire n'est pas possible facilement , mais ce que je veux vraiment faire est:

Disons que j'ai un lat et long d'un point de cheminement et un lat et long d'un utilisateur. Existe-t-il un moyen facile de les comparer pour décider quand dire à l'utilisateur qu'il se trouve à une distance raisonnablement proche du point de cheminement? Je me rends compte que le sujet est raisonnable, mais est-ce facilement faisable ou est-ce encore trop mathématique?

Voici une fonction javascript:

function measure(lat1, lon1, lat2, lon2){  // generally used geo measurement function
    var R = 6378.137; // Radius of earth in KM
    var dLat = lat2 * Math.PI / 180 - lat1 * Math.PI / 180;
    var dLon = lon2 * Math.PI / 180 - lon1 * Math.PI / 180;
    var a = Math.sin(dLat/2) * Math.sin(dLat/2) +
    Math.cos(lat1 * Math.PI / 180) * Math.cos(lat2 * Math.PI / 180) *
    Math.sin(dLon/2) * Math.sin(dLon/2);
    var c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a));
    var d = R * c;
    return d * 1000; // meters
}

Explication: https://en.wikipedia.org/wiki/Haversine_formula

La formule haversine détermine la distance du grand cercle entre deux points sur une sphère compte tenu de leurs longitudes et latitudes.

Étant donné que vous recherchez une formule simple, c'est probablement la façon la plus simple de le faire, en supposant que la Terre est une sphère d'une circonférence de 40075 km.

Longueur en mètres de 1 ° de latitude = toujours 111,32 km

Longueur en mètres de 1 ° de longitude = 40075 km * cos (latitude) / 360

Pour approximer les courtes distances entre deux coordonnées, j'ai utilisé des formules de http://en.wikipedia.org/wiki/Lat-lon :

m_per_deg_lat = 111132.954 - 559.822 * cos( 2 * latMid ) + 1.175 * cos( 4 * latMid);
m_per_deg_lon = 111132.954 * cos ( latMid );

.

Dans le code ci-dessous, j'ai laissé les nombres bruts pour montrer leur relation avec la formule de wikipedia.

double latMid, m_per_deg_lat, m_per_deg_lon, deltaLat, deltaLon,dist_m;

latMid = (Lat1+Lat2 )/2.0;  // or just use Lat1 for slightly less accurate estimate


m_per_deg_lat = 111132.954 - 559.822 * cos( 2.0 * latMid ) + 1.175 * cos( 4.0 * latMid);
m_per_deg_lon = (3.14159265359/180 ) * 6367449 * cos ( latMid );

deltaLat = fabs(Lat1 - Lat2);
deltaLon = fabs(Lon1 - Lon2);

dist_m = sqrt (  pow( deltaLat * m_per_deg_lat,2) + pow( deltaLon * m_per_deg_lon , 2) );

L'entrée de wikipedia indique que les calculs de distance sont inférieurs à 0,6 m pour 100 km longitudinalement et 1 cm pour 100 km latitudinalement, mais je ne l'ai pas vérifié car près de cette précision convient à mon utilisation.

Les latitudes et les longitudes spécifient des points, pas des distances, donc votre question est quelque peu absurde. Si vous demandez quelle est la distance la plus courte entre deux points (lat, lon), consultez cet article de Wikipedia sur les distances du grand cercle.

Il existe de nombreux outils qui faciliteront cette tâche. Voir la réponse de monjardin pour plus de détails sur ce qui est impliqué.

Cependant, cela n'est pas forcément difficile. On dirait que vous utilisez Java, donc je vous recommande d'examiner quelque chose comme GDAL . Il fournit des wrappers java pour leurs routines, et ils ont tous les outils nécessaires pour convertir Lat / Lon (coordonnées géographiques) en UTM (système de coordonnées projetées) ou une autre projection cartographique raisonnable.

UTM est agréable, car ce sont des compteurs, si faciles à travailler. Cependant, vous devrez obtenir la zone UTM appropriée pour qu'elle fasse du bon travail. Il existe quelques codes simples disponibles via Google pour trouver une zone appropriée pour une paire lat / longue.

La terre est une surface extrêmement irrégulière, il n'y a donc pas de formule simple pour le faire exactement. Vous devez vivre avec un modèle approximatif de la Terre et y projeter vos coordonnées. Le modèle que je vois généralement utilisé pour cela est le WGS 84 . C'est ce que les appareils GPS utilisent généralement pour résoudre exactement le même problème.

La NOAA a des logiciels que vous pouvez télécharger pour vous aider sur son site Web .

Voici la version R de la fonction bh- , juste au cas où:

measure <- function(lon1,lat1,lon2,lat2) {
    R <- 6378.137                                # radius of earth in Km
    dLat <- (lat2-lat1)*pi/180
    dLon <- (lon2-lon1)*pi/180
    a <- sin((dLat/2))^2 + cos(lat1*pi/180)*cos(lat2*pi/180)*(sin(dLon/2))^2
    c <- 2 * atan2(sqrt(a), sqrt(1-a))
    d <- R * c
    return (d * 1000)                            # distance in meters
}

Un mille marin (1852 mètres) est défini comme une minute d' arc de longitude à l'équateur. Cependant, vous devez définir une projection cartographique (voir aussi UTM ) dans laquelle vous travaillez pour que la conversion ait vraiment un sens.

Il existe plusieurs façons de calculer cela. Tous utilisent des approximations de trigonométrie sphérique où le rayon est celui de la terre.

essayez http://www.movable-type.co.uk/scripts/latlong.html pour un peu de méthodes et de code dans différentes langues.

    'below is from
'http://www.zipcodeworld.com/samples/distance.vbnet.html
Public Function distance(ByVal lat1 As Double, ByVal lon1 As Double, _
                         ByVal lat2 As Double, ByVal lon2 As Double, _
                         Optional ByVal unit As Char = "M"c) As Double
    Dim theta As Double = lon1 - lon2
    Dim dist As Double = Math.Sin(deg2rad(lat1)) * Math.Sin(deg2rad(lat2)) + _
                            Math.Cos(deg2rad(lat1)) * Math.Cos(deg2rad(lat2)) * _
                            Math.Cos(deg2rad(theta))
    dist = Math.Acos(dist)
    dist = rad2deg(dist)
    dist = dist * 60 * 1.1515
    If unit = "K" Then
        dist = dist * 1.609344
    ElseIf unit = "N" Then
        dist = dist * 0.8684
    End If
    Return dist
End Function
Public Function Haversine(ByVal lat1 As Double, ByVal lon1 As Double, _
                         ByVal lat2 As Double, ByVal lon2 As Double, _
                         Optional ByVal unit As Char = "M"c) As Double
    Dim R As Double = 6371 'earth radius in km
    Dim dLat As Double
    Dim dLon As Double
    Dim a As Double
    Dim c As Double
    Dim d As Double
    dLat = deg2rad(lat2 - lat1)
    dLon = deg2rad((lon2 - lon1))
    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)
    c = 2 * Math.Atan2(Math.Sqrt(a), Math.Sqrt(1 - a))
    d = R * c
    Select Case unit.ToString.ToUpper
        Case "M"c
            d = d * 0.62137119
        Case "N"c
            d = d * 0.5399568
    End Select
    Return d
End Function
Private Function deg2rad(ByVal deg As Double) As Double
    Return (deg * Math.PI / 180.0)
End Function
Private Function rad2deg(ByVal rad As Double) As Double
    Return rad / Math.PI * 180.0
End Function

Pour convertir la latitude et la longitude en représentation x et y, vous devez décider du type de projection cartographique à utiliser. Quant à moi, Elliptical Mercator me semble très bien. Ici vous pouvez trouver une implémentation (en Java aussi).

Si c'est suffisamment proche, vous pouvez vous en sortir en les traitant comme des coordonnées sur un plan plat. Cela fonctionne au niveau, par exemple, de la rue ou de la ville si une précision parfaite n'est pas requise et que tout ce dont vous avez besoin est une estimation approximative de la distance impliquée pour la comparer avec une limite arbitraire.

Basé sur la distance moyenne de dégressivité dans la Terre.

1 ° = 111 km;

En convertissant cela en radians et en divisant en mètres, prenez un nombre magique pour le RAD, en mètres: 0,000008998719243599958;

puis:

const RAD = 0.000008998719243599958;
Math.sqrt(Math.pow(lat1 - lat2, 2) + Math.pow(long1 - long2, 2)) / RAD;

Si vous voulez une solution simple, utilisez la formule Haversine comme indiqué dans les autres commentaires. Si vous avez une application sensible à la précision, gardez à l'esprit que la formule Haversine ne garantit pas une précision meilleure que 0,5% car elle suppose que la Terre est une sphère. Pour considérer que la Terre est un sphéroïde aplati, envisagez d'utiliser les formules de Vincenty . De plus, je ne sais pas quel rayon nous devrions utiliser avec la formule Haversine: {Équateur: 6 378,137 km, Polaire: 6 356 752 km, Volumétrique: 6 371,0088 km}.

Vous devez convertir les coordonnées en radians pour faire la géométrie sphérique. Une fois converti, vous pouvez calculer une distance entre les deux points. La distance peut alors être convertie en n'importe quelle mesure souhaitée.