Calcular distancia entre dos puntos en google maps V3

¿Cómo se calcula la distancia entre dos marcadores en Google Maps V3? (Similar a distanceFrom función en V2.)

Gracias..

Si desea calcularlo usted mismo, puede usar la fórmula de Haversine:

var rad = function(x) {
  return x * Math.PI / 180;
};

var getDistance = function(p1, p2) {
  var R = 6378137; // Earth’s mean radius in meter
  var dLat = rad(p2.lat() - p1.lat());
  var dLong = rad(p2.lng() - p1.lng());
  var a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
    Math.cos(rad(p1.lat())) * Math.cos(rad(p2.lat())) *
    Math.sin(dLong / 2) * Math.sin(dLong / 2);
  var c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
  var d = R * c;
  return d; // returns the distance in meter
};

De hecho, parece haber un método en GMap3. Es un método estático de la google.maps.geometry.spherical espacio de nombres

Toma como argumentos dos LatLng objetos y utilizará un radio terrestre predeterminado de 6378137 metros, aunque el radio predeterminado se puede anular con un valor personalizado si es necesario.

Asegúrate de incluir:

<script type="text/javascript" src="http://maps.google.com/maps/api/js?sensor=false&v=3&libraries=geometry"></script>

en la sección de tu cabeza.

La convocatoria será:

google.maps.geometry.spherical.computeDistanceBetween (latLngA, latLngB);

Ejemplo usando GPS latitud/longitud de 2 puntos.

var latitude1 = 39.46;
var longitude1 = -0.36;
var latitude2 = 40.40;
var longitude2 = -3.68;

var distance = google.maps.geometry.spherical.computeDistanceBetween(new google.maps.LatLng(latitude1, longitude1), new google.maps.LatLng(latitude2, longitude2));       

Simplemente agregue esto al comienzo de su código JavaScript:

google.maps.LatLng.prototype.distanceFrom = function(latlng) {
  var lat = [this.lat(), latlng.lat()]
  var lng = [this.lng(), latlng.lng()]
  var R = 6378137;
  var dLat = (lat[1]-lat[0]) * Math.PI / 180;
  var dLng = (lng[1]-lng[0]) * Math.PI / 180;
  var a = Math.sin(dLat/2) * Math.sin(dLat/2) +
  Math.cos(lat[0] * Math.PI / 180 ) * Math.cos(lat[1] * Math.PI / 180 ) *
  Math.sin(dLng/2) * Math.sin(dLng/2);
  var c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a));
  var d = R * c;
  return Math.round(d);
}

y luego use la función como esta:

var loc1 = new GLatLng(52.5773139, 1.3712427);
var loc2 = new GLatLng(52.4788314, 1.7577444);
var dist = loc2.distanceFrom(loc1);
alert(dist/1000);

//p1 and p2 are google.maps.LatLng(x,y) objects

function calcDistance(p1, p2) {
          var d = (google.maps.geometry.spherical.computeDistanceBetween(p1, p2) / 1000).toFixed(2);
          console.log(d);              
}

Aquí está la implementación c# de esta fórmula

 public class DistanceAlgorithm
{
    const double PIx = 3.141592653589793;
    const double RADIO = 6378.16;

    /// <summary>
    /// This class cannot be instantiated.
    /// </summary>
    private DistanceAlgorithm() { }

    /// <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 * RADIO) * 0.62137;//distance in miles
    }

}    

Con google puedes hacerlo usando el API esférica, google.maps.geometry.spherical.computeDistanceBetween (latLngA, latLngB);.

Sin embargo, si la precisión de una proyección esférica o una solución haversine no es lo suficientemente precisa para usted (por ejemplo, si está cerca del polo o calculando distancias más largas), debe usar una biblioteca diferente.

La mayoría de la información sobre el tema que encontré en Wikipedia aquí.

Un truco para ver si la precisión de cualquier algoritmo dado es adecuada es completar el radio máximo y mínimo de la tierra y ver si la diferencia puede causar problemas para su caso de uso. Muchos más detalles se pueden encontrar en Este artículo

Al final, Google API o Haversine servirán para la mayoría de los propósitos sin problemas.