Obliczanie odległości między dwoma lokalizacjami geograficznymi

Spróbuj Tego Kodu. tutaj mamy dwie wartości długości i szerokości geograficznej oraz selected_location.funkcja distanceTo (near_locations) zwraca odległość między tymi miejscami w metrach.

Location selected_location=new Location("locationA");
            selected_location.setLatitude(17.372102);
            selected_location.setLongitude(78.484196);
Location near_locations=new Location("locationB");
            near_locations.setLatitude(17.375775);
            near_locations.setLongitude(78.469218);
double distance=selected_location.distanceTo(near_locations);

Tutaj "odległość" to odległość między lokalizacjąa i lokalizacjąb (w metrach)

Istnieje tylko jedna lokalizacja użytkownika, więc można iterację listę pobliskich miejsc można wywołać funkcję distanceTo(), aby uzyskać odległość, można przechowywać w tablicy, jeśli chcesz.

Z tego, co rozumiem, distanceBetween() jest dla odległych miejsc, jej wyjście to elipsoida WGS84.

    private static Double _MilesToKilometers = 1.609344;
    private static Double _MilesToNautical = 0.8684;


    /// <summary>
    /// Calculates the distance between two points of latitude and longitude.
    /// Great Link - http://www.movable-type.co.uk/scripts/latlong.html
    /// </summary>
    /// <param name="coordinate1">First coordinate.</param>
    /// <param name="coordinate2">Second coordinate.</param>
    /// <param name="unitsOfLength">Sets the return value unit of length.</param>
    public static Double Distance(Coordinate coordinate1, Coordinate coordinate2, UnitsOfLength unitsOfLength)
    {

        double theta = coordinate1.getLongitude() - coordinate2.getLongitude();
        double distance = Math.sin(ToRadian(coordinate1.getLatitude())) * Math.sin(ToRadian(coordinate2.getLatitude())) +
                       Math.cos(ToRadian(coordinate1.getLatitude())) * Math.cos(ToRadian(coordinate2.getLatitude())) *
                       Math.cos(ToRadian(theta));

        distance = Math.acos(distance);
        distance = ToDegree(distance);
        distance = distance * 60 * 1.1515;

        if (unitsOfLength == UnitsOfLength.Kilometer)
            distance = distance * _MilesToKilometers;
        else if (unitsOfLength == UnitsOfLength.NauticalMiles)
            distance = distance * _MilesToNautical;

        return (distance);

    }

DistanceTo da ci odległość w metrach między dwoma podanymi lokalizacjami.odległość (cel podróży).

DistanceBetween podaje również odległość, ale zapisuje ją w tablicy float( wyniki [0]). doc mówi, że jeśli results ma długość 2 lub większą, początkowe łożysko jest zapisywane w results[1]. Jeśli results ma długość 3 lub większą, łożysko końcowe jest zapisywane w results [2]

Mam nadzieję, że to pomoże

I ' ve used distance to get the distance z punktu A do B myślę, że to jest droga do zrobienia.

public double distance(Double latitude, Double longitude, double e, double f) {
        double d2r = Math.PI / 180;

        double dlong = (longitude - f) * d2r;
        double dlat = (latitude - e) * d2r;
        double a = Math.pow(Math.sin(dlat / 2.0), 2) + Math.cos(e * d2r)
                * Math.cos(latitude * d2r) * Math.pow(Math.sin(dlong / 2.0), 2)
        double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
        double d = 6367 * c;
                return d;

    }

Chciałem sobie to zaimplementować, skończyło się na przeczytaniu strony wikipedii na Wzór odległości wielkich kół , ponieważ żaden kod nie był wystarczająco czytelny, aby użyć go jako podstawy.

C# przykład

    /// <summary>
    /// Calculates the distance between two locations using the Great Circle Distance algorithm
    /// <see cref="https://en.wikipedia.org/wiki/Great-circle_distance"/>
    /// </summary>
    /// <param name="first"></param>
    /// <param name="second"></param>
    /// <returns></returns>
    private static double DistanceBetween(GeoLocation first, GeoLocation second)
    {
        double longitudeDifferenceInRadians = Math.Abs(ToRadians(first.Longitude) - ToRadians(second.Longitude));

        double centralAngleBetweenLocationsInRadians = Math.Acos(
            Math.Sin(ToRadians(first.Latitude)) * Math.Sin(ToRadians(second.Latitude)) +
            Math.Cos(ToRadians(first.Latitude)) * Math.Cos(ToRadians(second.Latitude)) *
            Math.Cos(longitudeDifferenceInRadians));

        const double earthRadiusInMeters = 6357 * 1000;

        return earthRadiusInMeters * centralAngleBetweenLocationsInRadians;
    }

    private static double ToRadians(double degrees)
    {
        return degrees * Math.PI / 180;
    }