Uzyskaj odległość między dwoma punktami geograficznymi

Chcę stworzyć aplikację, która sprawdza najbliższe miejsce, w którym przebywa użytkownik. Mogę łatwo uzyskać lokalizację użytkownika i mam już listę miejsc z długością i szerokością geograficzną.

Jaki byłby najlepszy sposób na sprawdzenie najbliższego miejsca na liście w porównaniu z bieżącą lokalizacją użytkownika.

Nie mogłem znaleźć nic w Google API.

Location loc1 = new Location("");
loc1.setLatitude(lat1);
loc1.setLongitude(lon1);

Location loc2 = new Location("");
loc2.setLatitude(lat2);
loc2.setLongitude(lon2);

float distanceInMeters = loc1.distanceTo(loc2);

Źródła: http://developer.android.com/reference/android/location/Location.html#distanceTo(android.location.Location)

http://developer.android.com/reference/android/location/Location.html

Spójrz na distanceTo lub distanceBetween. Możesz utworzyć obiekt Location na podstawie szerokości i długości geograficznej:

Location location = new Location("");
location.setLatitude(lat);
location.setLongitude(lon);

Rozwiązanie przybliżone (oparte na rzucie równokątnym), znacznie szybsze (wymaga tylko 1 tryg. I 1 pierwiastka kwadratowego).

To przybliżenie jest istotne, jeśli Twoje punkty nie są zbyt daleko od siebie. To zawsze będzie zawyżone w porównaniu z rzeczywistą odległością haversine. Na przykład doda nie więcej niż 0,05382% do rzeczywistej odległości, jeśli różnica szerokości lub długości geograficznej między dwoma punktami nie przekracza 4 stopni dziesiętnych .

Standardowa formuła (Haversine) jest dokładna (to znaczy działa dla dowolnej długości / szerokości geograficznej na Ziemi), ale jest znacznie wolniejsza, ponieważ wymaga 7 pierwiastków trygonometrycznych i 2 pierwiastków kwadratowych. Jeśli kilka punktów nie jest zbyt daleko od siebie, a absolutna precyzja nie jest najważniejsza, możesz użyć tej przybliżonej wersji (Equirectangular), która jest znacznie szybsza, ponieważ wykorzystuje tylko jeden trygonometryczny i jeden pierwiastek kwadratowy.

// Approximate Equirectangular -- works if (lat1,lon1) ~ (lat2,lon2)
int R = 6371; // km
double x = (lon2 - lon1) * Math.cos((lat1 + lat2) / 2);
double y = (lat2 - lat1);
double distance = Math.sqrt(x * x + y * y) * R;

Możesz to dalej zoptymalizować, wykonując jedną z następujących czynności:

1. Usunięcie pierwiastka kwadratowego, jeśli po prostu porównasz odległość z inną (w takim przypadku porównaj obie odległości do kwadratu);
2. Rozkładając na czynniki cosinus, jeśli obliczasz odległość od jednego punktu wzorcowego do wielu innych (w takim przypadku wykonujesz rzut równokątny wyśrodkowany na punkcie wzorcowym, dzięki czemu możesz obliczyć cosinus raz dla wszystkich porównań).

Więcej informacji można znaleźć pod adresem : http://www.movable-type.co.uk/scripts/latlong.html

Istnieje ładna implementacja referencyjna formuły Haversine w kilku językach pod adresem : http://www.codecodex.com/wiki/Calculate_Distance_Between_Two_Points_on_a_Globe

Jest kilka metod, których możesz użyć, ale aby określić, która z nich jest najlepsza, najpierw musimy wiedzieć, czy znasz wysokość użytkownika, a także wysokość innych punktów?

W zależności od pożądanego poziomu dokładności możesz przyjrzeć się formułom Haversine lub Vincenty ...

Te strony wyszczególniają formuły, a dla mniej skłonnych matematycznie zawierają również wyjaśnienie, jak zaimplementować je w skrypcie!

Haversine Formula: http://www.movable-type.co.uk/scripts/latlong.html

Vincenty Formula: http://www.movable-type.co.uk/scripts/latlong-vincenty.html

Jeśli masz jakiekolwiek problemy z którymkolwiek ze znaczeń w formułach, po prostu skomentuj, a ja postaram się na nie odpowiedzieć :)

Istnieją dwa sposoby uzyskania odległości między LatLng.

public static void distanceBetween (double startLatitude, double startLongitude, double endLatitude, double endLongitude, float[] results)

Zobacz

i drugi

public float distanceTo (Location dest) jak odpowiedział praveen.

private float getDistance(double lat1, double lon1, double lat2, double lon2) {
        float[] distance = new float[2];
        Location.distanceBetween(lat1, lon1, lat2, lon2, distance);
        return distance[0];
    }

Po prostu użyj następującej metody, podaj szerokość i długość i uzyskaj odległość w metrach:

private static double distance_in_meter(final double lat1, final double lon1, final double lat2, final double lon2) {
    double R = 6371000f; // Radius of the earth in m
    double dLat = (lat1 - lat2) * Math.PI / 180f;
    double dLon = (lon1 - lon2) * Math.PI / 180f;
    double a = Math.sin(dLat/2) * Math.sin(dLat/2) +
            Math.cos(latlong1.latitude * Math.PI / 180f) * Math.cos(latlong2.latitude * Math.PI / 180f) *
                    Math.sin(dLon/2) * Math.sin(dLon/2);
    double c = 2f * Math.atan2(Math.sqrt(a), Math.sqrt(1-a));
    double d = R * c;
    return d;
}

możesz uzyskać odległość i czas za pomocą Google Map API Google Map API

po prostu prześlij pobrany plik JSON do tej metody, a otrzymasz w czasie rzeczywistym odległość i czas między dwoma latlongami

void parseJSONForDurationAndKMS(String json) throws JSONException {

    Log.d(TAG, "called parseJSONForDurationAndKMS");
    JSONObject jsonObject = new JSONObject(json);
    String distance;
    String duration;
    distance = jsonObject.getJSONArray("routes").getJSONObject(0).getJSONArray("legs").getJSONObject(0).getJSONObject("distance").getString("text");
    duration = jsonObject.getJSONArray("routes").getJSONObject(0).getJSONArray("legs").getJSONObject(0).getJSONObject("duration").getString("text");

    Log.d(TAG, "distance : " + distance);
    Log.d(TAG, "duration : " + duration);

    distanceBWLats.setText("Distance : " + distance + "\n" + "Duration : " + duration);


}

a = sin² (Δφ / 2) + cos φ1 ⋅ cos φ2 ⋅ sin² (Δλ / 2)

c = 2 ⋅ atan2 (√a, √ (1 − a))

odległość = R ⋅ c

gdzie φ to szerokość geograficzna, λ to długość geograficzna, R to promień Ziemi (średni promień = 6 371 km);

zwróć uwagę, że kąty muszą być podane w radianach, aby przejść do funkcji trygonometrycznych!

fun distanceInMeter(firstLocation: Location, secondLocation: Location): Double {
    val earthRadius = 6371000.0
    val deltaLatitudeDegree = (firstLocation.latitude - secondLocation.latitude) * Math.PI / 180f
    val deltaLongitudeDegree = (firstLocation.longitude - secondLocation.longitude) * Math.PI / 180f
    val a = sin(deltaLatitudeDegree / 2).pow(2) +
            cos(firstLocation.latitude * Math.PI / 180f) * cos(secondLocation.latitude * Math.PI / 180f) *
            sin(deltaLongitudeDegree / 2).pow(2)
    val c = 2f * atan2(sqrt(a), sqrt(1 - a))
    return earthRadius * c
}


data class Location(val latitude: Double, val longitude: Double)