Come convertire latitudine o longitudine in metri?

Question

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

Edit: Ok sembra quello che voglio fare non è possibile facilmente, ma quello che voglio veramente fare è:

dire che ho un lat e lunga di un punto di strada e un lat e lungo di un utente c'è un modo semplice per confrontarli per decidere quando comunicare all'utente che si trovano entro lo ragionevolmente a distanza ravvicinata del punto di passaggio? Mi rendo conto che l'argomento è ragionevole ma è facilmente fattibile o ancora eccessivamente matematico?

Answer 1

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

Answer 2

Un miglio nautico (1852 metri) è definito come uno arcminute di longitudine all'equatore. Tuttavia, è necessario definire uno map projection (vedere anche UTM) in cui si sta lavorando affinché la conversione abbia davvero senso.

Answer 3

Latitudini e longitudini specificano i punti, non le distanze, quindi la tua domanda è alquanto priva di senso. Se stai chiedendo la distanza più breve tra due (lat, lon) punti, vedi this Wikipedia article su distanze a grande cerchio.

Answer 4

Ci sono molti strumenti che renderanno questo facile. Vedi monjardin's answer per maggiori dettagli su ciò che è coinvolto.

Tuttavia, fare questo non è necessariamente difficile. Sembra che tu stia usando Java, quindi ti consiglio di guardare 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 proiettate) o qualche altra ragionevole proiezione di mappe.

UTM è bello, perché è metri, così facile da lavorare. Tuttavia, è necessario ottenere l'appropriato UTM zone per fare un buon lavoro. Ci sono alcuni semplici codici disponibili tramite googling per trovare una zona appropriata per una coppia lat/long.

Answer 5

'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 

Answer 6

Ci sono diversi modi per calcolare questo. Tutti usano le approssimazioni della trigonometria sferica dove il raggio è quello della terra.

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

Answer 7

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 usato per questo è WGS 84. Questo è quello che i dispositivi GPS solitamente usano per risolvere esattamente lo stesso problema.

NOAA ha alcuni software che è possibile scaricare per aiutare con questo on their website.

Answer 8

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

Answer 9

Se è sufficientemente vicino è possibile farli franca trattandoli come coordinate su un piano. Funziona su scala stradale o cittadina se non è richiesta una precisione perfetta e tutto ciò di cui hai bisogno è un'ipotesi approssimativa sulla distanza da confrontare con un limite arbitrario.

Answer 10

Per convertire latitudine e longitudine in x e di rappresentanza y è necessario decidere quale tipo di proiezione cartografica da utilizzare. Per quanto mi riguarda, Elliptical Mercator sembra molto bene. Here puoi trovare un'implementazione (anche in Java).

Answer 11

Sulla base della distanza media per degress sulla Terra.

1 ° = 111 km;

Convertendo questo per radianti e dividendo per metri, prendi un numero magico per il RAD, in metri: 0.000008998719243599958;

quindi:

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

Answer 12

per approssimare brevi distanze tra due coordinate ho usato 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 distanza sono all'interno di 0,6 m per 100 km in senso longitudinale e uno centimetri per 100 km latitudinale, ma non hanno verificato questo come da nessuna parte vicino che la precisione va bene per il mio uso.

Answer 13

ecco la versione R di b-h-'s function, nel caso in cui:

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 
} 

Answer 14

Dato siete alla ricerca di una semplice formula, questo è probabilmente il modo più semplice per farlo, partendo dal presupposto che la Terra è una sfera del perimetro 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