algorithm - online - formula de haversine excel

Calcular la distancia entre dos puntos de latitud-longitud?(Fórmula de Haversine)

Question

¿Cómo calculo la distancia entre dos puntos especificados por latitud y longitud?

Para aclarar, me gustaría la distancia en kilómetros; los puntos utilizan el sistema WGS84 y me gustaría entender las precisiones relativas de los enfoques disponibles.

Answer 1

Aquí está la implementación VB.NET, esta implementación le dará el resultado en KM o Millas según el valor Enum que pase.

Public Enum DistanceType
Miles
KiloMeters
End Enum
Public Structure Position
Public Latitude As Double
Public Longitude As Double
End Structure
Public Class Haversine
Public Function Distance(Pos1 As Position,
Pos2 As Position,
DistType As DistanceType) As Double
Dim R As Double = If((DistType = DistanceType.Miles), 3960, 6371)
Dim dLat As Double = Me.toRadian(Pos2.Latitude - Pos1.Latitude)
Dim dLon As Double = Me.toRadian(Pos2.Longitude - Pos1.Longitude)
Dim a As Double = Math.Sin(dLat / 2) * Math.Sin(dLat / 2) + Math.Cos(Me.toRadian(Pos1.Latitude)) * Math.Cos(Me.toRadian(Pos2.Latitude)) * Math.Sin(dLon / 2) * Math.Sin(dLon / 2)
Dim c As Double = 2 * Math.Asin(Math.Min(1, Math.Sqrt(a)))
Dim result As Double = R * c
Return result
End Function
Private Function toRadian(val As Double) As Double
Return (Math.PI / 180) * val
End Function
End Class

Answer 2

Aquí está la implementación de respuesta aceptada portada a Java en caso de que alguien la necesite.

package com.project529.garage.util;
/**
* Mean radius.
*/
private static double EARTH_RADIUS = 6371;
/**
* Returns the distance between two sets of latitudes and longitudes in meters.
* <p/>
* Based from the following JavaScript SO answer:
* http://.com/questions/27928/calculate-distance-between-two-latitude-longitude-points-haversine-formula,
* which is based on https://en.wikipedia.org/wiki/Haversine_formula (error rate: ~0.55%).
*/
public double getDistanceBetween(double lat1, double lon1, double lat2, double lon2) {
double dLat = toRadians(lat2 - lat1);
double dLon = toRadians(lon2 - lon1);
double a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
Math.cos(toRadians(lat1)) * Math.cos(toRadians(lat2)) *
Math.sin(dLon / 2) * Math.sin(dLon / 2);
double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
double d = EARTH_RADIUS * c;
return d;
}
public double toRadians(double degrees) {
return degrees * (Math.PI / 180);
}

Answer 3

Aquí está mi implementación de java para calcular la distancia a través de grados decimales después de alguna búsqueda. Utilicé el radio medio del mundo (de wikipedia) en km. Si desea obtener millas, use el radio mundial en millas.

public static double distanceLatLong2(double lat1, double lng1, double lat2, double lng2)
{
double earthRadius = 6371.0d; // KM: use mile here if you want mile result
double dLat = toRadian(lat2 - lat1);
double dLng = toRadian(lng2 - lng1);
double a = Math.pow(Math.sin(dLat/2), 2) +
Math.cos(toRadian(lat1)) * Math.cos(toRadian(lat2)) *
Math.pow(Math.sin(dLng/2), 2);
double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a));
return earthRadius * c; // returns result kilometers
}
public static double toRadian(double degrees)
{
return (degrees * Math.PI) / 180.0d;
}

Answer 4

Aquí está una implementación de escritura de la fórmula Haversine

static getDistanceFromLatLonInKm(lat1: number, lon1: number, lat2: number, lon2: number): number {
var deg2Rad = deg => {
return deg * Math.PI / 180;
}
var r = 6371; // Radius of the earth in km
var dLat = deg2Rad(lat2 - lat1);
var dLon = deg2Rad(lon2 - lon1);
var 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);
var c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
var d = r * c; // Distance in km
return d;
}

Answer 5

Aquí hay un ejemplo en postgres sql (en km, para la versión de millas, reemplace 1.609344 por la versión 0.8684)

CREATE OR REPLACE FUNCTION public.geodistance(alat float, alng float, blat
float, blng float)
RETURNS float AS
$BODY$
DECLARE
v_distance float;
BEGIN
v_distance = asin( sqrt(
sin(radians(blat-alat)/2)^2
+ (
(sin(radians(blng-alng)/2)^2) *
cos(radians(alat)) *
cos(radians(blat))
)
)
) * cast(''7926.3352'' as float) * cast(''1.609344'' as float) ;
RETURN v_distance;
END
$BODY$
language plpgsql VOLATILE SECURITY DEFINER;
alter function geodistance(alat float, alng float, blat float, blng float)
owner to postgres;

Answer 6

Aquí hay una función javascript simple que puede ser útil desde este link ... de alguna manera relacionada, pero estamos usando el complemento javascript de Google Earth en lugar de mapas

function getApproximateDistanceUnits(point1, point2) {
var xs = 0;
var ys = 0;
xs = point2.getX() - point1.getX();
xs = xs * xs;
ys = point2.getY() - point1.getY();
ys = ys * ys;
return Math.sqrt(xs + ys);
}

Las unidades no están en distancia, sino en términos de una relación relativa a tus coordenadas. Hay otros cálculos relacionados que puede sustituir por el link función getApproximateDistanceUnits link

Luego uso esta función para ver si una longitud de latitud está dentro del radio

function isMapPlacemarkInRadius(point1, point2, radi) {
if (point1 && point2) {
return getApproximateDistanceUnits(point1, point2) <= radi;
} else {
return 0;
}
}

punto puede definirse como

 $$.getPoint = function(lati, longi) {
var location = {
x: 0,
y: 0,
getX: function() { return location.x; },
getY: function() { return location.y; }
};
location.x = lati;
location.y = longi;
return location;
};

luego, puede hacer lo suyo para ver si un punto está dentro de una región con un radio, por ejemplo:

 //put it on the map if within the range of a specified radi assuming 100,000,000 units
var iconpoint = Map.getPoint(pp.latitude, pp.longitude);
var centerpoint = Map.getPoint(Settings.CenterLatitude, Settings.CenterLongitude);
//approx ~200 units to show only half of the globe from the default center radius
if (isMapPlacemarkInRadius(centerpoint, iconpoint, 120)) {
addPlacemark(pp.latitude, pp.longitude, pp.name);
}
else {
otherSidePlacemarks.push({
latitude: pp.latitude,
longitude: pp.longitude,
name: pp.name
});
}

Answer 7

Aquí hay una implementación de C #:

static class DistanceAlgorithm
{
const double PIx = 3.141592653589793;
const double RADIUS = 6378.16;
/// <summary>
/// Convert degrees to Radians
/// </summary>
/// <param name="x">Degrees</param>
/// <returns>The equivalent in radians</returns>
public static double Radians(double x)
{
return x * PIx / 180;
}
/// <summary>
/// Calculate the distance between two places.
/// </summary>
/// <param name="lon1"></param>
/// <param name="lat1"></param>
/// <param name="lon2"></param>
/// <param name="lat2"></param>
/// <returns></returns>
public static double DistanceBetweenPlaces(
double lon1,
double lat1,
double lon2,
double lat2)
{
double dlon = Radians(lon2 - lon1);
double dlat = Radians(lat2 - lat1);
double a = (Math.Sin(dlat / 2) * Math.Sin(dlat / 2)) + Math.Cos(Radians(lat1)) * Math.Cos(Radians(lat2)) * (Math.Sin(dlon / 2) * Math.Sin(dlon / 2));
double angle = 2 * Math.Atan2(Math.Sqrt(a), Math.Sqrt(1 - a));
return angle * RADIUS;
}

Answer 8

Aquí hay una implementación java de la fórmula de Haversine.

public final static double AVERAGE_RADIUS_OF_EARTH_KM = 6371;
public int calculateDistanceInKilometer(double userLat, double userLng,
double venueLat, double venueLng) {
double latDistance = Math.toRadians(userLat - venueLat);
double lngDistance = Math.toRadians(userLng - venueLng);
double a = Math.sin(latDistance / 2) * Math.sin(latDistance / 2)
+ Math.cos(Math.toRadians(userLat)) * Math.cos(Math.toRadians(venueLat))
* Math.sin(lngDistance / 2) * Math.sin(lngDistance / 2);
double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
return (int) (Math.round(AVERAGE_RADIUS_OF_EARTH_KM * c));
}

Tenga en cuenta que aquí estamos redondeando la respuesta al km más cercano.

Answer 9

Como se señaló, un cálculo preciso debe tener en cuenta que la Tierra no es una esfera perfecta. Aquí hay algunas comparaciones de los diversos algoritmos ofrecidos aquí:

geoDistance(50,5,58,3)
Haversine: 899 km
Maymenn: 833 km
Keerthana: 897 km
google.maps.geometry.spherical.computeDistanceBetween(): 900 km
geoDistance(50,5,-58,-3)
Haversine: 12030 km
Maymenn: 11135 km
Keerthana: 10310 km
google.maps.geometry.spherical.computeDistanceBetween(): 12044 km
geoDistance(.05,.005,.058,.003)
Haversine: 0.9169 km
Maymenn: 0.851723 km
Keerthana: 0.917964 km
google.maps.geometry.spherical.computeDistanceBetween(): 0.917964 km
geoDistance(.05,80,.058,80.3)
Haversine: 33.37 km
Maymenn: 33.34 km
Keerthana: 33.40767 km
google.maps.geometry.spherical.computeDistanceBetween(): 33.40770 km

En distancias pequeñas, el algoritmo de Keerthana parece coincidir con el de Google Maps. Google Maps no parece seguir ningún algoritmo simple, lo que sugiere que puede ser el método más preciso aquí.

De todos modos, aquí hay una implementación de Javascript del algoritmo de Keerthana:

function geoDistance(lat1, lng1, lat2, lng2){
const a = 6378.137; // equitorial radius in km
const b = 6356.752; // polar radius in km
var sq = x => (x*x);
var sqr = x => Math.sqrt(x);
var cos = x => Math.cos(x);
var sin = x => Math.sin(x);
var radius = lat => sqr((sq(a*a*cos(lat))+sq(b*b*sin(lat)))/(sq(a*cos(lat))+sq(b*sin(lat))));
lat1 = lat1 * Math.PI / 180;
lng1 = lng1 * Math.PI / 180;
lat2 = lat2 * Math.PI / 180;
lng2 = lng2 * Math.PI / 180;
var R1 = radius(lat1);
var x1 = R1*cos(lat1)*cos(lng1);
var y1 = R1*cos(lat1)*sin(lng1);
var z1 = R1*sin(lat1);
var R2 = radius(lat2);
var x2 = R2*cos(lat2)*cos(lng2);
var y2 = R2*cos(lat2)*sin(lng2);
var z2 = R2*sin(lat2);
return sqr(sq(x1-x2)+sq(y1-y2)+sq(z1-z2));
}

Answer 10

Condensé el cálculo simplificando la fórmula.

Aquí está en Ruby:

include Math
earth_radius_mi = 3959
radians = lambda { |deg| deg * PI / 180 }
coord_radians = lambda { |c| { :lat => radians[c[:lat]], :lng => radians[c[:lng]] } }
# from/to = { :lat => (latitude_in_degrees), :lng => (longitude_in_degrees) }
def haversine_distance(from, to)
from, to = coord_radians[from], coord_radians[to]
cosines_product = cos(to[:lat]) * cos(from[:lat]) * cos(from[:lng] - to[:lng])
sines_product = sin(to[:lat]) * sin(from[:lat])
return earth_radius_mi * acos(cosines_product + sines_product)
end

Answer 11

Definitivamente, la transmisión es una buena fórmula para la mayoría de los casos, otras respuestas ya lo incluyen, por lo que no voy a tomar el espacio. Pero es importante tener en cuenta que no importa qué fórmula se use (sí, no solo una). Debido a la gran variedad de precisión posible, así como el tiempo de cálculo requerido. La elección de la fórmula requiere un poco más de reflexión que una respuesta sencilla y sencilla.

Esta publicación de una persona en la NASA es la mejor que encontré al discutir las opciones.

http://www.cs.nyu.edu/visual/home/proj/tiger/gisfaq.html

Por ejemplo, si solo está ordenando filas por distancia en un radio de 100 millas. La fórmula de la tierra plana será mucho más rápida que la haversina.

HalfPi = 1.5707963;
R = 3956; /* the radius gives you the measurement unit*/
a = HalfPi - latoriginrad;
b = HalfPi - latdestrad;
u = a * a + b * b;
v = - 2 * a * b * cos(longdestrad - longoriginrad);
c = sqrt(abs(u + v));
return R * c;

Note que solo hay un coseno y una raíz cuadrada. Vs 9 de ellos en la fórmula de Haversine.

Answer 12

En Mysql usa la siguiente función pasa los parámetros como usando POINT(LONG,LAT)

CREATE FUNCTION `distance`(a POINT, b POINT)
RETURNS double
DETERMINISTIC
BEGIN
RETURN
GLength( LineString(( PointFromWKB(a)), (PointFromWKB(b)))) * 100000; -- To Make the distance in meters
END;

Answer 13

En las otras respuestas falta una implementación en r .

Calcular la distancia entre dos puntos es bastante sencillo con la función distm del paquete geosphere :

distm(p1, p2, fun = distHaversine)

dónde:

p1 = longitude/latitude for point(s)
p2 = longitude/latitude for point(s)
# type of distance calculation
fun = distCosine / distHaversine / distVincentySphere / distVincentyEllipsoid

Como la Tierra no es perfectamente esférica, la fórmula de Vincenty para elipsoides es probablemente la mejor manera de calcular distancias. Así, en el paquete de geosphere que usas entonces:

distm(p1, p2, fun = distVincentyEllipsoid)

Por supuesto, no necesariamente tiene que usar el paquete geosphere , también puede calcular la distancia en la base R con una función:

hav.dist <- function(long1, lat1, long2, lat2) {
R <- 6371
diff.long <- (long2 - long1)
diff.lat <- (lat2 - lat1)
a <- sin(diff.lat/2)^2 + cos(lat1) * cos(lat2) * sin(diff.long/2)^2
b <- 2 * asin(pmin(1, sqrt(a)))
d = R * b
return(d)
}

Answer 14

Esta es una función PHP simple que dará una aproximación muy razonable (con un margen de error de +/- 1%).

<?php
function distance($lat1, $lon1, $lat2, $lon2) {
$pi80 = M_PI / 180;
$lat1 *= $pi80;
$lon1 *= $pi80;
$lat2 *= $pi80;
$lon2 *= $pi80;
$r = 6372.797; // mean radius of Earth in km
$dlat = $lat2 - $lat1;
$dlon = $lon2 - $lon1;
$a = sin($dlat / 2) * sin($dlat / 2) + cos($lat1) * cos($lat2) * sin($dlon / 2) * sin($dlon / 2);
$c = 2 * atan2(sqrt($a), sqrt(1 - $a));
$km = $r * $c;
//echo ''<br/>''.$km;
return $km;
}
?>

Como se dijo antes; La tierra NO es una esfera. Es como una pelota de béisbol antigua y vieja con la que Mark McGwire decidió practicar: está lleno de golpes y golpes. Los cálculos más simples (como este) lo tratan como una esfera.

Los diferentes métodos pueden ser más o menos precisos según dónde se encuentre en este ovoide irregular Y a qué distancia están sus puntos (cuanto más cerca están, menor es el margen de error absoluto). Cuanto más precisa sea su expectativa, más complejas serán las matemáticas.

Para más información: wikipedia distancia geográfica.

Answer 15

Este link puede ser útil para usted, ya que detalla el uso de la fórmula de Haversine para calcular la distancia.

Extracto:

Esta secuencia de comandos [en Javascript] calcula las distancias de gran círculo entre los dos puntos, es decir, la distancia más corta sobre la superficie de la tierra, utilizando la fórmula ''Haversine''.

function getDistanceFromLatLonInKm(lat1,lon1,lat2,lon2) {
var R = 6371; // Radius of the earth in km
var dLat = deg2rad(lat2-lat1); // deg2rad below
var dLon = deg2rad(lon2-lon1);
var 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)
;
var c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a));
var d = R * c; // Distance in km
return d;
}
function deg2rad(deg) {
return deg * (Math.PI/180)
}

Answer 16

Este script [en PHP] calcula distancias entre los dos puntos.

public static function getDistanceOfTwoPoints($source, $dest, $unit=''K'') {
$lat1 = $source[0];
$lon1 = $source[1];
$lat2 = $dest[0];
$lon2 = $dest[1];
$theta = $lon1 - $lon2;
$dist = sin(deg2rad($lat1)) * sin(deg2rad($lat2)) + cos(deg2rad($lat1)) * cos(deg2rad($lat2)) * cos(deg2rad($theta));
$dist = acos($dist);
$dist = rad2deg($dist);
$miles = $dist * 60 * 1.1515;
$unit = strtoupper($unit);
if ($unit == "K") {
return ($miles * 1.609344);
}
else if ($unit == "M")
{
return ($miles * 1.609344 * 1000);
}
else if ($unit == "N") {
return ($miles * 0.8684);
}
else {
return $miles;
}
}

Answer 17

Hay un buen ejemplo aquí para calcular la distancia con PHP http://www.geodatasource.com/developers/php :

 function distance($lat1, $lon1, $lat2, $lon2, $unit) {
$theta = $lon1 - $lon2;
$dist = sin(deg2rad($lat1)) * sin(deg2rad($lat2)) + cos(deg2rad($lat1)) * cos(deg2rad($lat2)) * cos(deg2rad($theta));
$dist = acos($dist);
$dist = rad2deg($dist);
$miles = $dist * 60 * 1.1515;
$unit = strtoupper($unit);
if ($unit == "K") {
return ($miles * 1.609344);
} else if ($unit == "N") {
return ($miles * 0.8684);
} else {
return $miles;
}
}

Answer 18

Implementación de Python El origen es el centro de los Estados Unidos contiguos.

from haversine import haversine
origin = (39.50, 98.35)
paris = (48.8567, 2.3508)
haversine(origin, paris, miles=True)

Para obtener la respuesta en kilómetros simplemente configure millas = falso.

Answer 19

Más bien depende de la precisión con la que desee ser y en qué datum se definen la latitud y la longitud. Muy, muy aproximadamente, haces un pequeño gatillo esférico, pero corregir el hecho de que la Tierra no es una esfera hace que las fórmulas sean más complicadas.

Answer 20

Muchas gracias por todo esto. Usé el siguiente código en mi aplicación para iPhone Objective-C:

const double PIx = 3.141592653589793;
const double RADIO = 6371; // Mean radius of Earth in Km
double convertToRadians(double val) {
return val * PIx / 180;
}
-(double)kilometresBetweenPlace1:(CLLocationCoordinate2D) place1 andPlace2:(CLLocationCoordinate2D) place2 {
double dlon = convertToRadians(place2.longitude - place1.longitude);
double dlat = convertToRadians(place2.latitude - place1.latitude);
double a = ( pow(sin(dlat / 2), 2) + cos(convertToRadians(place1.latitude))) * cos(convertToRadians(place2.latitude)) * pow(sin(dlon / 2), 2);
double angle = 2 * asin(sqrt(a));
return angle * RADIO;
}

La latitud y la longitud están en decimal. No utilicé min () para la llamada asin () ya que las distancias que estoy usando son tan pequeñas que no lo requieren.

Dio respuestas incorrectas hasta que pasé los valores en radianes. Ahora son más o menos los valores obtenidos en la aplicación Map de Apple :-)

Actualización adicional:

Si está utilizando iOS4 o posterior, entonces Apple proporciona algunos métodos para hacer esto, de modo que la misma funcionalidad se lograría con:

-(double)kilometresBetweenPlace1:(CLLocationCoordinate2D) place1 andPlace2:(CLLocationCoordinate2D) place2 {
MKMapPoint start, finish;
start = MKMapPointForCoordinate(place1);
finish = MKMapPointForCoordinate(place2);
return MKMetersBetweenMapPoints(start, finish) / 1000;
}

Answer 21

Necesitaba calcular muchas distancias entre los puntos de mi proyecto, así que seguí adelante e intenté optimizar el código, que he encontrado aquí. En promedio, en diferentes navegadores, mi nueva implementación se ejecuta 2 veces más rápido que la respuesta más votada.

function distance(lat1, lon1, lat2, lon2) {
var p = 0.017453292519943295; // Math.PI / 180
var c = Math.cos;
var a = 0.5 - c((lat2 - lat1) * p)/2 +
c(lat1 * p) * c(lat2 * p) *
(1 - c((lon2 - lon1) * p))/2;
return 12742 * Math.asin(Math.sqrt(a)); // 2 * R; R = 6371 km
}

Puedes jugar con mi jsPerf y ver los resultados aquí .

Recientemente tuve que hacer lo mismo en python, así que aquí hay una implementación de python :

from math import cos, asin, sqrt
def distance(lat1, lon1, lat2, lon2):
p = 0.017453292519943295 #Pi/180
a = 0.5 - cos((lat2 - lat1) * p)/2 + cos(lat1 * p) * cos(lat2 * p) * (1 - cos((lon2 - lon1) * p)) / 2
return 12742 * asin(sqrt(a)) #2*R*asin...

Y por el bien de la integridad: Haversine en wiki.

Answer 22

No me gusta agregar otra respuesta, pero la API de Google maps v.3 tiene geometría esférica (y más). Después de convertir su WGS84 a grados decimales, puede hacer esto:

<script src="http://maps.google.com/maps/api/js?sensor=false&libraries=geometry" type="text/javascript"></script>
distance = google.maps.geometry.spherical.computeDistanceBetween(
new google.maps.LatLng(fromLat, fromLng),
new google.maps.LatLng(toLat, toLng));

No se sabe qué tan precisos son los cálculos de Google o incluso qué modelo se usa (aunque dice "esférico" en lugar de "geoide". Por cierto, la distancia en "línea recta" obviamente será diferente de la distancia si uno viaja en el superficie de la tierra que es lo que todos parecen estar suponiendo.

Answer 23

Para calcular la distancia entre dos puntos en una esfera, debe hacer el cálculo del Gran Círculo .

Hay una serie de bibliotecas C / C ++ para ayudar con la proyección de mapas en MapTools si necesita reproyectar sus distancias a una superficie plana. Para ello necesitará la cadena de proyección de los distintos sistemas de coordenadas.

También puede encontrar MapWindow una herramienta útil para visualizar los puntos. También como su código abierto es una guía útil sobre cómo usar la biblioteca proj.dll, que parece ser la biblioteca de proyección de código abierto principal.

Answer 24

Podría haber una solución más simple y más correcta: el perímetro de la tierra es de 40,000 km en el ecuador, aproximadamente 37,000 en el ciclo de Greenwich (o cualquier longitud). Así:

pythagoras = function (lat1, lon1, lat2, lon2) {
function sqr(x) {return x * x;}
function cosDeg(x) {return Math.cos(x * Math.PI / 180.0);}
var earthCyclePerimeter = 40000000.0 * cosDeg((lat1 + lat2) / 2.0);
var dx = (lon1 - lon2) * earthCyclePerimeter / 360.0;
var dy = 37000000.0 * (lat1 - lat2) / 360.0;
return Math.sqrt(sqr(dx) + sqr(dy));
};

Estoy de acuerdo en que debe ajustarse, ya que yo mismo dije que es un elipsoide, por lo que el radio que se multiplica por el coseno varía. Pero es un poco más preciso. Comparado con Google Maps y redujo el error significativamente.

Answer 25

Publico aquí mi ejemplo de trabajo.

Enumere todos los puntos en la tabla que tienen distancia entre un punto designado (usamos un punto aleatorio - lat: 45.20327, largo: 23.7806) menos de 50 KM, con latitud y longitud, en MySQL (los campos de la tabla son coord_lat y coord_long):

Enumere todos los que tienen DISTANCIA <50, en Kilómetros (considerado radio de la Tierra 6371 KM):

SELECT denumire, (6371 * acos( cos( radians(45.20327) ) * cos( radians( coord_lat ) ) * cos( radians( 23.7806 ) - radians(coord_long) ) + sin( radians(45.20327) ) * sin( radians(coord_lat) ) )) AS distanta
FROM obiective
WHERE coord_lat<>''''
AND coord_long<>''''
HAVING distanta<50
ORDER BY distanta desc

El ejemplo anterior se probó en MySQL 5.0.95 y 5.5.16 (Linux).

Answer 26

Puede usar la compilación en CLLocationDistance para calcular esto:

CLLocation *location1 = [[CLLocation alloc] initWithLatitude:latitude1 longitude:longitude1];
CLLocation *location2 = [[CLLocation alloc] initWithLatitude:latitude2 longitude:longitude2];
[self distanceInMetersFromLocation:location1 toLocation:location2]
- (int)distanceInMetersFromLocation:(CLLocation*)location1 toLocation:(CLLocation*)location2 {
CLLocationDistance distanceInMeters = [location1 distanceFromLocation:location2];
return distanceInMeters;
}

En tu caso si quieres kilómetros solo divide por 1000.

Answer 27

Todas las respuestas anteriores asumen que la tierra es una esfera. Sin embargo, una aproximación más precisa sería la de un esferoide oblato.

a= 6378.137#equitorial radius in km
b= 6356.752#polar radius in km
def Distance(lat1, lons1, lat2, lons2):
lat1=math.radians(lat1)
lons1=math.radians(lons1)
R1=(((((a**2)*math.cos(lat1))**2)+(((b**2)*math.sin(lat1))**2))/((a*math.cos(lat1))**2+(b*math.sin(lat1))**2))**0.5 #radius of earth at lat1
x1=R*math.cos(lat1)*math.cos(lons1)
y1=R*math.cos(lat1)*math.sin(lons1)
z1=R*math.sin(lat1)
lat2=math.radians(lat2)
lons2=math.radians(lons2)
R1=(((((a**2)*math.cos(lat2))**2)+(((b**2)*math.sin(lat2))**2))/((a*math.cos(lat2))**2+(b*math.sin(lat2))**2))**0.5 #radius of earth at lat2
x2=R*math.cos(lat2)*math.cos(lons2)
y2=R*math.cos(lat2)*math.sin(lons2)
z2=R*math.sin(lat2)
return ((x1-x2)**2+(y1-y2)**2+(z1-z2)**2)**0.5

Answer 28

//JAVA
public Double getDistanceBetweenTwoPoints(Double latitude1, Double longitude1, Double latitude2, Double longitude2) {
final int RADIUS_EARTH = 6371;
double dLat = getRad(latitude2 - latitude1);
double dLong = getRad(longitude2 - longitude1);
double a = Math.sin(dLat / 2) * Math.sin(dLat / 2) + Math.cos(getRad(latitude1)) * Math.cos(getRad(latitude2)) * Math.sin(dLong / 2) * Math.sin(dLong / 2);
double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
return (RADIUS_EARTH * c) * 1000;
}
private Double getRad(Double x) {
return x * Math.PI / 180;
}

Answer 29

function getDistanceFromLatLonInKm(lat1,lon1,lat2,lon2,units) {
var R = 6371; // Radius of the earth in km
var dLat = deg2rad(lat2-lat1); // deg2rad below
var dLon = deg2rad(lon2-lon1);
var 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)
;
var c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a));
var d = R * c;
var miles = d / 1.609344;
if ( units == ''km'' ) {
return d;
} else {
return miles;
}}

La solución de Chuck, válida para millas también.

Answer 30

function getDistanceFromLatLonInKm(position1, position2) {
"use strict";
var deg2rad = function (deg) { return deg * (Math.PI / 180); },
R = 6371,
dLat = deg2rad(position2.lat - position1.lat),
dLng = deg2rad(position2.lng - position1.lng),
a = Math.sin(dLat / 2) * Math.sin(dLat / 2)
+ Math.cos(deg2rad(position1.lat))
* Math.cos(deg2rad(position1.lat))
* Math.sin(dLng / 2) * Math.sin(dLng / 2),
c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
return R * c;
}
console.log(getDistanceFromLatLonInKm(
{lat: 48.7931459, lng: 1.9483572},
{lat: 48.827167, lng: 2.2459745}
));