Calcule la distancia entre dos puntos de latitud y longitud? (Fórmula Haversine)

¿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 usan el sistema WGS84 y me gustaría entender las precisiones relativas de los enfoques disponibles.

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

Extracto:

Este script [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) } 

Necesitaba calcular una gran cantidad de distancias entre los puntos para mi proyecto, así que seguí adelante y traté de optimizar el código, lo he encontrado aquí. En promedio, en diferentes navegadores, mi nueva implementación es 2 veces más rápida 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 necesité 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 para completar: Haversine en wiki.

Aquí hay una implementación de C #:

 static class DistanceAlgorithm { const double PIx = 3.141592653589793; const double RADIUS = 6378.16; ///  /// Convert degrees to Radians ///  /// Degrees /// The equivalent in radians public static double Radians(double x) { return x * PIx / 180; } ///  /// Calculate the distance between two places. ///  ///  ///  ///  ///  ///  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; } 

Aquí hay una implementación java de la fórmula 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.

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

 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; } 

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

Dio respuestas incorrectas hasta que aprobé los valores en radianes, ahora es más o menos lo mismo que los valores obtenidos de la aplicación Map de Apple 🙂

Actualización adicional:

Si está utilizando iOS4 o posterior, entonces Apple proporciona algunos métodos para hacerlo, 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; } 

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

 '.$km; return $km; } ?> 

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

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

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

Publiqué aquí mi ejemplo de trabajo.

Enumera 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 tengan DISTANCIA <50, en Kilómetros (se considera 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 fue probado en MySQL 5.0.95 y 5.5.16 (Linux).

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 los elipsoides es probablemente la mejor manera de calcular distancias. Por lo tanto, en el paquete de la geosphere utilizas entonces:

 distm(p1, p2, fun = distVincentyEllipsoid) 

Por supuesto, no necesariamente tiene que usar el paquete de 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) } 

Puede usar la construcció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.

El haversine es definitivamente una buena fórmula para la mayoría de los casos, otras respuestas ya la incluyen, así 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 amplia gama 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 simple respuesta obvia.

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 tierra plana será mucho más rápida que la haversine.

 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; 

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

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

  distance = google.maps.geometry.spherical.computeDistanceBetween( new google.maps.LatLng(fromLat, fromLng), new google.maps.LatLng(toLat, toLng)); 

No hay información sobre cuán precisos son los cálculos de Google o incluso qué modelo se usa (aunque sí dice “esférico” en lugar de “geoide”. Por cierto, la distancia “en línea recta” será obviamente diferente de la distancia si uno viaja en el superficie de la tierra que es lo que todos parecen estar asumiendo.

Más bien depende de qué tan preciso sea y qué datos se definen en latitud y longitud. Muy, muy aproximadamente, haces un poco de trigonometría esférica, pero corrigiendo el hecho de que la tierra no es una esfera hace que las fórmulas sean más complicadas.

Podría haber una solución más simple y más correcta: el perímetro de la tierra es 40,000 km en el ecuador, alrededor de 37,000 en ciclo 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 ser ajustado como, yo mismo dije que es un elipsoide, por lo que el radio a multiplicar por el coseno varía. Pero es un poco más preciso. En comparación con Google Maps, redujo significativamente el error.

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 achatado.

 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 

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 del mapa en MapTools si necesita reproyectar sus distancias a una superficie plana. Para hacer esto necesitarás la cadena de proyección de los diversos sistemas de coordenadas.

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

Implimentation Python Origin 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 establece millas = falso.

Aquí hay una implementación mecanografiada 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; } 

Este script [en PHP] calcula las 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; } } 

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 

Aquí está la implementación de respuesta aceptada portada a Java en caso de que alguien lo 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. * 

* Based from the following JavaScript SO answer: * http://stackoverflow.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); }

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; } } 

Aquí está la implementación de VB.NET, esta implementación le dará el resultado en KM o en Millas en función de un valor de 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 

Aquí está mi implementación de Java para la distancia de cálculo a través de grados decimales después de algunas búsquedas. Utilicé el radio medio del mundo (de wikipedia) en km. Si quiere millas de resultados, 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; } 

En Mysql use la siguiente función pase 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; 
 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} )); 

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; 

Como se señaló, un cálculo preciso debería 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)); } 

Aquí hay una función de JavaScript simple que puede ser útil desde este enlace . De alguna manera relacionada, pero estamos usando el plugin de google earth javascript 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 la distancia sino en términos de una relación relativa a sus coordenadas. Hay otros cálculos relacionados que puede sustituir el enlace de la función getApproximateDistanceUnits aquí

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

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

punto se puede definir 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; }; 

entonces puedes hacer lo tuyo para ver si un punto está dentro de una región con un radio decir:

  //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 }); } 
 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 también para millas.

 //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; }