Question

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)?

Modifier: Ok, ce que je veux faire n’est pas possible facilement , mais ce que je veux vraiment faire, c’est:

Disons que j’ai un point de cheminement très long et qu’un utilisateur est un moyen facile de les comparer et de décider quand il convient de dire à cet utilisateur qu’il se trouve dans un raisonnablement distance du point de passage? Je réalise que le sujet est raisonnable, mais est-ce facile à faire ou encore excessivement maths-y?

Était-ce utile?

La solution

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 de leurs latitudes.

Autres conseils

Étant donné que vous recherchez une formule simple, il s'agit probablement du moyen le 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 & # 176; de latitude = toujours 111,32 km

Longueur en mètres de 1 & # 176; 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 à moins de 0,6 m pour 100 km dans le sens longitudinal et de 1 cm pour 100 km dans le sens de la longitude, mais je n’ai pas vérifié cette précision, 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, long), consultez 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é à cette fin est WGS 84 . C’est ce que les appareils GPS utilisent habituellement pour résoudre exactement le même problème.

La NOAA propose des logiciels que vous pouvez télécharger pour vous aider avec ce sur leur site Web . .

De nombreux outils vous faciliteront la 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, je vous recommande donc d’examiner quelque chose comme GDAL . Il fournit des wrappers java pour leurs routines et dispose 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 est agréable, car ce sont des compteurs, si faciles à utiliser. Cependant, vous aurez besoin de la zone UTM appropriée pour pouvoir faire du bon travail. . Quelques codes simples sont disponibles via Google pour trouver la zone appropriée pour une paire lat / longue.

Voici la version R de la 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
}

Un mille marin (1852 mètres) est défini comme un arcminute 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.

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

1 & # 176; = 111 km;

La conversion pour les radians et la division pour les mètres, est un nombre magique pour le RAD, en mètres: 0.000008998719243599958;

alors:

const RAD = 0.000008998719243599958;
Math.sqrt(Math.pow(lat1 - lat2, 2) + Math.pow(long1 - long2, 2)) / RAD;
    '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 (également en Java).

S'il 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 simplement besoin d'une estimation approximative de la distance nécessaire pour la comparer à une limite arbitraire.

Si vous souhaitez une solution simple, utilisez la la formule de Haversine décrite 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%, dans l'hypothèse où la Terre est un cercle. Pour considérer que la Terre est un sphéroïde oblat, envisagez d'utiliser les 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 effectuer la géométrie sphérique. Une fois la conversion effectuée, vous pouvez calculer une distance entre les deux points. La distance peut alors être convertie en toute mesure souhaitée.

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top