Come convertire la latitudine o la longitudine in metri?

Se ho una lettura di latitudine o longitudine in formato NMEA standard, esiste un modo / formula semplice per convertire quella lettura in metri, che posso quindi implementare in Java (J9)?

Modifica: Ok sembra che quello che voglio fare non sia possibile facilmente , tuttavia quello che voglio veramente fare è:

Supponiamo che io abbia una latitudine e longitudine di un waypoint e una lat e long di un utente, esiste un modo semplice per confrontarli per decidere quando dire all'utente che si trovano a una distanza ragionevolmente vicina dal waypoint? Mi rendo conto che il soggetto è ragionevole, ma è facilmente realizzabile o è ancora eccessivamente matematico?

Ecco una funzione 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
}

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

La formula haversine determina la distanza del cerchio grande tra due punti su una sfera date le loro longitudini e latitudini.

Dato che stai cercando una formula semplice, questo è probabilmente il modo più semplice per farlo, supponendo che la Terra sia una sfera con una circonferenza di 40075 km.

Lunghezza in metri di 1 ° di latitudine = sempre 111,32 km

Lunghezza in metri di 1 ° di longitudine = 40075 km * cos (latitudine) / 360

Per approssimare brevi distanze tra due coordinate ho usato le formule da 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 );

.

Nel codice qui sotto ho lasciato i numeri grezzi per mostrare la loro relazione con la formula di 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) );

La voce di wikipedia afferma che i calcoli della distanza sono entro 0,6 m per 100 km longitudinalmente e 1 cm per 100 km latitudinalmente, ma non l'ho verificato perché vicino a quella precisione va bene per il mio uso.

Latitudini e longitudini specificano punti, non distanze, quindi la tua domanda è in qualche modo priva di senso. Se stai chiedendo la distanza più breve tra due punti (lat, lon), consulta questo articolo di Wikipedia sulle distanze del cerchio grande.

Ci sono molti strumenti che renderanno questo facile. Vedi la risposta di monjardin per maggiori dettagli su cosa è coinvolto.

Tuttavia, farlo non è necessariamente difficile. Sembra che tu stia usando Java, quindi consiglierei di esaminare qualcosa come GDAL . Fornisce wrapper Java per le loro routine e hanno tutti gli strumenti necessari per convertire da Lat / Lon (coordinate geografiche) a UTM (sistema di coordinate proiettato) o qualche altra ragionevole proiezione cartografica.

L'UTM è carino, perché sono metri, così facile da lavorare. Tuttavia, dovrai ottenere la zona UTM appropriata per fare un buon lavoro. Ci sono alcuni semplici codici disponibili tramite googling per trovare una zona appropriata per una coppia latitudine / longitudine.

La terra è una superficie fastidiosamente irregolare, quindi non esiste una formula semplice per farlo esattamente. Devi vivere con un modello approssimativo della terra e proiettare le tue coordinate su di esso. Il modello che di solito vedo utilizzato per questo è WGS 84 . Questo è ciò che i dispositivi GPS usano solitamente per risolvere esattamente lo stesso problema.

NOAA ha alcuni software che puoi scaricare per aiutare con questo sul loro sito web .

Ecco la versione R della funzione bh , per ogni evenienza:

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 miglio nautico (1852 metri) è definito come un minuto d' arco di longitudine all'equatore. Tuttavia, è necessario definire una proiezione cartografica (vedere anche UTM ) in cui si sta lavorando affinché la conversione abbia davvero senso.

Ci sono diversi modi per calcolarlo. Tutti usano approssimazioni di trigonometria sferica dove il raggio è quello della terra.

prova http://www.mohable-type.co.uk/scripts/latlong.html per un po 'di metodi e codice in diverse lingue.

    '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

Per convertire la latitudine e la longitudine nella rappresentazione xey è necessario decidere quale tipo di proiezione cartografica utilizzare. Per quanto mi riguarda, Elliptical Mercator sembra molto bene. Qui puoi trovare un'implementazione (anche in Java).

Se è sufficientemente vicino puoi farla franca trattandole come coordinate su un piano piatto. Funziona, ad esempio, a livello di strada o di città se non è richiesta una precisione perfetta e tutto ciò di cui hai bisogno è un'ipotesi approssimativa sulla distanza coinvolta per confrontarla con un limite arbitrario.

Basato sulla distanza media per la discesa nella Terra.

1 ° = 111 km;

Convertendo questo valore per i radianti e dividendolo per metri, si prende un numero magico per il RAD, in metri: 0,000008998719243599958;

poi:

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

Se vuoi una soluzione semplice, usa la formula Haversine come delineato dagli altri commenti. Se si dispone di un'applicazione sensibile alla precisione, tenere presente che la formula Haversine non garantisce una precisione migliore dello 0,5% poiché si presume che la terra sia una sfera. Per considerare che la Terra è uno sferoide oblato, considera l'utilizzo delle formule di Vincenty . Inoltre, non sono sicuro di quale raggio dovremmo usare con la formula Haversine: {Equatore: 6,378,137 km, Polare: 6,356,752 km, Volumetrico: 6,371,0088 km}.

È necessario convertire le coordinate in radianti per eseguire la geometria sferica. Una volta convertito, puoi calcolare una distanza tra i due punti. La distanza può quindi essere convertita in qualsiasi misura desideri.