Como converter latitude ou longitude em metros?

Se eu tiver uma leitura de latitude ou longitude no formato NMEA padrão, existe uma maneira / fórmula fácil de converter essa leitura em metros, que eu posso implementar em Java (J9)?

Edit: Ok, parece que o que eu quero fazer não é possível facilmente , no entanto, o que eu realmente quero fazer é:

Digamos que eu possua um ponto de latência e longitude e um usuário de latência e longitude há uma maneira fácil de compará-los e decidir quando informar ao usuário que eles estão a uma distância razoavelmente próxima do waypoint? Sei que razoável é o assunto, mas isso é facilmente factível ou ainda excessivamente matemático-y?

Aqui está uma função 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
}

Explicação: https://en.wikipedia.org/wiki/Haversine_formula

A fórmula do haversine determina a distância do grande círculo entre dois pontos em uma esfera, dadas suas longitudes e latitudes.

Dado que você está procurando uma fórmula simples, esta é provavelmente a maneira mais simples de fazê-lo, supondo que a Terra seja uma esfera com uma circunferência de 40075 km.

Comprimento em metros de 1 ° de latitude = sempre 111,32 km

Comprimento em metros de 1 ° de longitude = 40075 km * cos (latitude) / 360

Para aproximar distâncias curtas entre duas coordenadas, usei fórmulas em 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 );

.

No código abaixo, deixei os números brutos para mostrar sua relação com a fórmula da 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) );

A entrada da Wikipedia afirma que a distância calculada está dentro de 0,6 m por 100 km longitudinalmente e 1 cm por 100 km latitudinalmente, mas não verifiquei isso, pois em qualquer lugar próximo dessa precisão é bom para o meu uso.

Latitudes e longitudes especificam pontos, não distâncias; portanto, sua pergunta é um tanto absurda. Se você está perguntando sobre a menor distância entre dois pontos (lat, lon), consulte este artigo da Wikipedia sobre distâncias de grandes círculos.

Existem muitas ferramentas que tornarão isso fácil. Veja a resposta de monjardin para mais detalhes sobre o que está envolvido.

No entanto, fazer isso não é necessariamente difícil. Parece que você está usando Java, então eu recomendaria procurar algo como o GDAL . Ele fornece wrappers java para suas rotinas e eles têm todas as ferramentas necessárias para converter de Lat / Lon (coordenadas geográficas) para UTM (sistema de coordenadas projetadas) ou alguma outra projeção de mapa razoável.

O UTM é bom, porque é medidor, muito fácil de trabalhar. No entanto, você precisará obter a zona UTM apropriada para fazer um bom trabalho. Existem alguns códigos simples disponíveis no Google para encontrar uma zona apropriada para um par de lat / long.

A terra é uma superfície irritantemente irregular, então não existe uma fórmula simples para fazer isso exatamente. Você tem que viver com um modelo aproximado da Terra e projetar suas coordenadas nela. O modelo que normalmente vejo usado para isso é o WGS 84 . É isso que os dispositivos GPS costumam usar para resolver exatamente o mesmo problema.

O NOAA possui algum software que você pode baixar para ajudar com isso em seu site .

Aqui está a versão R da função bh- , apenas no caso de:

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
}

Uma milha náutica (1852 metros) é definida como um minuto de arco de longitude no equador. No entanto, você precisa definir uma projeção de mapa (consulte também UTM ) na qual você está trabalhando para que a conversão faça realmente sentido.

Existem algumas maneiras de calcular isso. Todos eles usam aproximações de trigonometria esférica onde o raio é o da Terra.

tente http://www.movable-type.co.uk/scripts/latlong.html para conhecer alguns métodos e códigos em diferentes idiomas.

    '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

Para converter latitude e longitude nas representações x e y, você precisa decidir que tipo de projeção de mapa usar. Quanto a mim, o Elliptical Mercator parece muito bem. Aqui você pode encontrar uma implementação (em Java também).

Se estiver suficientemente perto, você poderá tratá-las como coordenadas em um plano. Isso funciona no nível da rua ou da cidade, se não for necessária uma precisão perfeita e tudo o que você precisa é de uma estimativa aproximada da distância envolvida para comparar com um limite arbitrário.

Baseado na distância média para ingressar na Terra.

1 ° = 111km;

Convertendo isso para radianos e dividindo por metros, é um número mágico para o RAD, em metros: 0,000008998719243599958;

então:

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

Se você deseja uma solução simples, use a fórmula Haversine, conforme descrito nos outros comentários. Se você tem uma aplicação sensível à precisão, lembre-se de que a fórmula Haversine não garante uma precisão melhor que 0,5%, pois assume que a Terra é uma esfera. Para considerar que a Terra é um esferóide oblato, considere o uso das fórmulas de Vincenty . Além disso, não tenho certeza de qual raio devemos usar com a fórmula Haversine: {Equador: 6.378.137 km, Polar: 6.356.752 km, Volumétrica: 6.371,0088 km}.

Você precisa converter as coordenadas em radianos para fazer a geometria esférica. Depois de convertido, você pode calcular uma distância entre os dois pontos. A distância então pode ser convertida para qualquer medida que você desejar.