Comment convertir latitude ou 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 dans Java (J9)?
Edit: Ok semble que ce que je veux faire ne soit pas possible facilement , mais ce que je veux vraiment faire est:
Supposons que j’ai un point de cheminement long et long et qu’un utilisateur long et long est un moyen facile de les comparer pour décider quand indiquer à l’utilisateur qu’il se trouve dans un intervalle raisonnable distance proche du point de passage? Je réalise que le sujet est raisonnable, mais est-ce facile à faire ou encore excessivement 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 d'une sphère en fonction 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 soit une sphère de périmètre 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 de 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 wikipedia indique que les calculs de distance sont inférieurs à 0,6 m pour 100 km dans le sens de la longueur et à 1 cm pour 100 km dans le sens de la longitude, mais je ne l'ai pas vérifié, car la précision est correcte pour mon utilisation.
Les latitudes et les longitudes spécifient des points et non des distances. Votre question est donc un peu absurde. Si vous parlez de la distance la plus courte entre deux points (lat, lon), voyez cet article de Wikipedia sur les distances de grand cercle.
La terre est une surface irrégulièrement agaçante, il n’existe 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 WGS 84 . C’est ce que les appareils GPS utilisent habituellement pour résoudre exactement le même problème.
La NOAA a quelques logiciels que vous pouvez télécharger pour vous aider avec ceci sur leur site web .
Il existe de nombreux outils qui faciliteront cette tâche. Voir réponse de monjardin pour plus de détails sur ce qui est impliqué.
Cependant, cela n'est pas nécessairement difficile. On dirait que vous utilisez Java, je vous recommande donc de regarder quelque chose comme GDAL . Il fournit Java wrappers pour leurs routines, et ils disposent de tous les outils nécessaires pour convertir de Lat/Lon (coordonnées géographiques) en UTM (système de coordonnées projetées) ou toute autre projection cartographique raisonnable.
UTM c'est Nice, parce que ce sont des mètres, si facile à travailler. Cependant, vous devrez vous procurer le bon zone UTM pour faire du bon travail. Il existe quelques codes simples disponibles sur Google pour trouver une zone appropriée pour une paire lat/long.
Voici la version R de fonction de b-h- , 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
}
Basé sur la distance moyenne de dégressivité sur la Terre.
1 ° = 111 km;
En convertissant cela pour les radians et en divisant les mètres, prenez un nombre magique pour le RAD, en mètres: 0.000008998719243599958;
ensuite:
const RAD = 0.000008998719243599958;
Math.sqrt(Math.pow(lat1 - lat2, 2) + Math.pow(long1 - long2, 2)) / RAD;
Il y a 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.
Un mille marin (1852 mètres) est défini comme un 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.
'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 choisir le type de projection cartographique à utiliser. Quant à moi, l'elliptique Mercator semble très bien. Ici vous pouvez trouver une implémentation (dans Java aussi).
Si le son est suffisamment proche, vous pouvez les traiter comme des coordonnées sur un plan plat. Cela fonctionne au niveau de la rue ou de la ville, par exemple, si une précision parfaite n'est pas requise et si vous avez juste besoin d'une estimation approximative de la distance nécessaire pour la comparer à une limite arbitraire.