Calcola la distanza tra due punti in google maps V3

Come calcoli la distanza tra due marker in Google Maps V3? (Simile alla distanceFrom funzione inV2.)

Grazie..

Se vuoi calcolarlo da solo, allora puoi usare la formula di 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 }; 

Sembra che ci sia un metodo in GMap3. È un metodo statico dello spazio google.maps.geometry.spherical nomi google.maps.geometry.spherical .

Prende come argomenti due oggetti LatLng e utilizzerà un raggio di terra predefinito di 6378137 metri, sebbene il raggio predefinito possa essere sostituito con un valore personalizzato, se necessario.

Assicurati di includere:

  

nella tua sezione di testa.

La chiamata sarà:

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

C’è il computeDistanceBetween (lat, lng) nella nuova V3 Geometry Library

Esempio utilizzando la latitudine / longitudine GPS di 2 punti.

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

Aggiungi questo all’inizio del tuo codice 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); } 

e quindi utilizzare la funzione in questo modo:

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

Ecco l’implementazione c # di questo forumula

  public class DistanceAlgorithm { const double PIx = 3.141592653589793; const double RADIO = 6378.16; ///  /// This class cannot be instantiated. ///  private DistanceAlgorithm() { } ///  /// 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 * RADIO) * 0.62137;//distance in miles } } 

Con google puoi farlo usando l’ api sferica , google.maps.geometry.spherical.computeDistanceBetween (latLngA, latLngB); .

Tuttavia, se la precisione di una proiezione sferica o di una soluzione haversine non è abbastanza precisa per te (ad esempio se sei vicino al polo o calcolando lunghe distanze), dovresti usare una libreria diversa.

La maggior parte delle informazioni sull’argomento che ho trovato su Wikipedia qui .

Un trucco per vedere se la precisione di un dato algoritmo è adeguata è quella di riempire il raggio massimo e minimo della terra e vedere se la differenza potrebbe causare problemi per il tuo caso d’uso. Molti altri dettagli possono essere trovati in questo articolo

Alla fine la google api o haversine servirà la maggior parte degli scopi senza problemi.

Usando PHP, puoi calcolare la distanza usando questa semplice funzione:

 // per calcolare la distanza tra due lat e lon

 function calculate_distance ($ lat1, $ lon1, $ lat2, $ lon2, $ unit = 'N') 
 { 
   $ 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); 
   $ miglia = $ dist * 60 * 1.1515;
   $ unit = strtoupper ($ unit);

   if ($ unit == "K") {
     ritorno ($ miglia * 1.609344); 
   } else if ($ unit == "N") {
       ritorno ($ miglia * 0,8684);
     } altro {
         ritorno $ miglia;
       }
 }

 // la funzione termina qui

È ansible ottenere una buona precisione al costo di un tempo di elaborazione maggiore con l’algoritmo di Vincenty, implementato in Javascript .

SOLUZIONE OFFLINE – Algoritmo di Haversine

In Javascript

 var _eQuatorialEarthRadius = 6378.1370; var _d2r = (Math.PI / 180.0); function HaversineInM(lat1, long1, lat2, long2) { return (1000.0 * HaversineInKM(lat1, long1, lat2, long2)); } function HaversineInKM(lat1, long1, lat2, long2) { var dlong = (long2 - long1) * _d2r; var dlat = (lat2 - lat1) * _d2r; var a = Math.pow(Math.sin(dlat / 2.0), 2.0) + Math.cos(lat1 * _d2r) * Math.cos(lat2 * _d2r) * Math.pow(Math.sin(dlong / 2.0), 2.0); var c = 2.0 * Math.atan2(Math.sqrt(a), Math.sqrt(1.0 - a)); var d = _eQuatorialEarthRadius * c; return d; } var meLat = -33.922982; var meLong = 151.083853; var result1 = HaversineInKM(meLat, meLong, -32.236457779983745, 148.69094705162837); var result2 = HaversineInKM(meLat, meLong, -33.609020205923713, 150.77061469270831); 

C #

 using System; public class Program { public static void Main() { Console.WriteLine("Hello World"); var meLat = -33.922982; double meLong = 151.083853; var result1 = HaversineInM(meLat, meLong, -32.236457779983745, 148.69094705162837); var result2 = HaversineInM(meLat, meLong, -33.609020205923713, 150.77061469270831); Console.WriteLine(result1); Console.WriteLine(result2); } static double _eQuatorialEarthRadius = 6378.1370D; static double _d2r = (Math.PI / 180D); private static int HaversineInM(double lat1, double long1, double lat2, double long2) { return (int)(1000D * HaversineInKM(lat1, long1, lat2, long2)); } private static double HaversineInKM(double lat1, double long1, double lat2, double long2) { double dlong = (long2 - long1) * _d2r; double dlat = (lat2 - lat1) * _d2r; double a = Math.Pow(Math.Sin(dlat / 2D), 2D) + Math.Cos(lat1 * _d2r) * Math.Cos(lat2 * _d2r) * Math.Pow(Math.Sin(dlong / 2D), 2D); double c = 2D * Math.Atan2(Math.Sqrt(a), Math.Sqrt(1D - a)); double d = _eQuatorialEarthRadius * c; return d; } } 

Riferimento: https://en.wikipedia.org/wiki/Great-circle_distance

Dovevo farlo … La sceneggiatura d’azione

 //just make sure you pass a number to the function because it would accept you mother in law... public var rad = function(x:*) {return x*Math.PI/180;} protected function distHaversine(p1:Object, p2:Object):Number { var R:int = 6371; // earth's mean radius in km var dLat:Number = rad(p2.lat() - p1.lat()); var dLong:Number = rad(p2.lng() - p1.lng()); var a:Number = 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:Number = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a)); var d:Number = R * c; return d; } 

Nel mio caso era meglio calcolare questo in SQL Server, dal momento che volevo prendere la posizione corrente e quindi cercare tutti i codici postali entro una certa distanza dalla posizione corrente. Avevo anche un DB che conteneva un elenco di codici postali e i loro long lat. Saluti

 --will return the radius for a given number create function getRad(@variable float)--function to return rad returns float as begin declare @retval float select @retval=(@variable * PI()/180) --print @retval return @retval end go --calc distance --drop function dbo.getDistance create function getDistance(@cLat float,@cLong float, @tLat float, @tLong float) returns float as begin declare @emr float declare @dLat float declare @dLong float declare @a float declare @distance float declare @c float set @emr = 6371--earth mean set @dLat = dbo.getRad(@tLat - @cLat); set @dLong = dbo.getRad(@tLong - @cLong); set @a = sin(@dLat/2)*sin(@dLat/2)+cos(dbo.getRad(@cLat))*cos(dbo.getRad(@tLat))*sin(@dLong/2)*sin(@dLong/2); set @c = 2*atn2(sqrt(@a),sqrt([email protected])) set @distance = @emr*@c; set @distance = @distance * 0.621371 -- i needed it in miles --print @distance return @distance; end go --get all zipcodes within 2 miles, the hardcoded #'s would be passed in by C# select * from cityzips a where dbo.getDistance(29.76,-95.38,a.lat,a.long) <3 order by zipcode 
 //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; } 

Vedi la distanzaDa funzione sull’object GLatLng; i parametri della funzione sono leggermente cambiati tra v2 e v3.

  /** * Calculates the haversine distance between point A, and B. * @param {number[]} latlngA [lat, lng] point A * @param {number[]} latlngB [lat, lng] point B * @param {boolean} isMiles If we are using miles, else km. */ function haversineDistance(latlngA, latlngB, isMiles) { const squared = x => x * x; const toRad = x => (x * Math.PI) / 180; const R = 6371; // Earth's mean radius in km const dLat = toRad(latlngB[0] - latlngA[0]); const dLon = toRad(latlngB[1] - latlngA[1]); const dLatSin = squared(Math.sin(dLat / 2)); const dLonSin = squared(Math.sin(dLon / 2)); const a = dLatSin + (Math.cos(toRad(latlngA[0])) * Math.cos(toRad(latlngB[0])) * dLonSin); const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a)); let distance = R * c; if (isMiles) distance /= 1.609344; return distance; } 

Ho trovato una versione online che è giusta all’80% ma collegata al parametro sbagliato ed è incoerente nell’uso degli input, questa versione è stata risolta completamente

https://developers.google.com/maps/documentation/javascript/examples/distance-matrix

Questo nome di indirizzo del codice o risultato delle coordinate

Per calcolare la distanza su Google Maps, puoi utilizzare l’API delle indicazioni stradali. Questo sarà uno dei modi più facili per farlo. Per ottenere dati da Google Server, puoi utilizzare Retrofit o Volley. Entrambi hanno il loro vantaggio. Dai un’occhiata al seguente codice in cui ho utilizzato il retrofit per implementarlo:

 private void build_retrofit_and_get_response(String type) { String url = "https://maps.googleapis.com/maps/"; Retrofit retrofit = new Retrofit.Builder() .baseUrl(url) .addConverterFactory(GsonConverterFactory.create()) .build(); RetrofitMaps service = retrofit.create(RetrofitMaps.class); Call call = service.getDistanceDuration("metric", origin.latitude + "," + origin.longitude,dest.latitude + "," + dest.longitude, type); call.enqueue(new Callback() { @Override public void onResponse(Response response, Retrofit retrofit) { try { //Remove previous line from map if (line != null) { line.remove(); } // This loop will go through all the results and add marker on each location. for (int i = 0; i < response.body().getRoutes().size(); i++) { String distance = response.body().getRoutes().get(i).getLegs().get(i).getDistance().getText(); String time = response.body().getRoutes().get(i).getLegs().get(i).getDuration().getText(); ShowDistanceDuration.setText("Distance:" + distance + ", Duration:" + time); String encodedString = response.body().getRoutes().get(0).getOverviewPolyline().getPoints(); List list = decodePoly(encodedString); line = mMap.addPolyline(new PolylineOptions() .addAll(list) .width(20) .color(Color.RED) .geodesic(true) ); } } catch (Exception e) { Log.d("onResponse", "There is an error"); e.printStackTrace(); } } @Override public void onFailure(Throwable t) { Log.d("onFailure", t.toString()); } }); } 

Sopra è il codice della funzione build_retrofit_and_get_response per il calcolo della distanza. Di seguito è corrispondente interfaccia Retrofit:

 package com.androidtutorialpoint.googlemapsdistancecalculator; import com.androidtutorialpoint.googlemapsdistancecalculator.POJO.Example; import retrofit.Call; import retrofit.http.GET; import retrofit.http.Query; public interface RetrofitMaps { /* * Retrofit get annotation with our URL * And our method that will return us details of student. */ @GET("api/directions/json?key=AIzaSyC22GfkHu9FdgT9SwdCWMwKX1a4aohGifM") Call getDistanceDuration(@Query("units") String units, @Query("origin") String origin, @Query("destination") String destination, @Query("mode") String mode); 

}

Spero che questo spieghi la tua domanda. Ti auguro il meglio 🙂

Fonte: Google Maps Distance Calculator

È abbastanza semplice utilizzare il servizio Google Distance Matrix

Il primo passo è triggersre il servizio Distance Matrix dalla console API di google. restituisce le distanze tra un insieme di posizioni. E applica questa semplice funzione

 function initMap() { var bounds = new google.maps.LatLngBounds; var markersArray = []; var origin1 = {lat:23.0203, lng: 72.5562}; //var origin2 = 'Ahmedabad, India'; var destinationA = {lat:23.0436503, lng: 72.55008939999993}; //var destinationB = {lat: 23.2156, lng: 72.6369}; var destinationIcon = 'https://chart.googleapis.com/chart?' + 'chst=d_map_pin_letter&chld=D|FF0000|000000'; var originIcon = 'https://chart.googleapis.com/chart?' + 'chst=d_map_pin_letter&chld=O|FFFF00|000000'; var map = new google.maps.Map(document.getElementById('map'), { center: {lat: 55.53, lng: 9.4}, zoom: 10 }); var geocoder = new google.maps.Geocoder; var service = new google.maps.DistanceMatrixService; service.getDistanceMatrix({ origins: [origin1], destinations: [destinationA], travelMode: 'DRIVING', unitSystem: google.maps.UnitSystem.METRIC, avoidHighways: false, avoidTolls: false }, function(response, status) { if (status !== 'OK') { alert('Error was: ' + status); } else { var originList = response.originAddresses; var destinationList = response.destinationAddresses; var outputDiv = document.getElementById('output'); outputDiv.innerHTML = ''; deleteMarkers(markersArray); var showGeocodedAddressOnMap = function(asDestination) { var icon = asDestination ? destinationIcon : originIcon; return function(results, status) { if (status === 'OK') { map.fitBounds(bounds.extend(results[0].geometry.location)); markersArray.push(new google.maps.Marker({ map: map, position: results[0].geometry.location, icon: icon })); } else { alert('Geocode was not successful due to: ' + status); } }; }; for (var i = 0; i < originList.length; i++) { var results = response.rows[i].elements; geocoder.geocode({'address': originList[i]}, showGeocodedAddressOnMap(false)); for (var j = 0; j < results.length; j++) { geocoder.geocode({'address': destinationList[j]}, showGeocodedAddressOnMap(true)); //outputDiv.innerHTML += originList[i] + ' to ' + destinationList[j] + ': ' + results[j].distance.text + ' in ' + results[j].duration.text + '
'; outputDiv.innerHTML += results[j].distance.text + '
'; } } } }); }

Dove origin1 è la tua posizione e destinazioneA è la posizione di destindazione. Puoi aggiungere due o più dati sopra.

Rad Full Documentation con un esempio