Berechnung der Entfernung zwischen zwei geografischen Standorten

Bitte werfen Sie etwas Licht auf diese Situation

Im Moment habe ich zwei Arrays mit Breiten- und Längengraden von Orten in der Nähe und habe auch den Benutzerstandort Latiude und Longiude. Jetzt möchte ich die Entfernung zwischen Benutzerstandort und Orten in der Nähe berechnen und sie in der Listenansicht anzeigen.

Ich weiß, dass es eine Methode zur Berechnung der Entfernung als gibt

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

Was nun das Problem ist, ist, wie man diese beiden Arrays mit nahe beieinander liegenden Breiten- und Längengraden bei dieser Methode passiert und das Array von Entfernungen erhält.

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

Schauen Sie in distanceTo oder distanceBetween. Sie können ein Standortobjekt aus einem Breiten- und Längengrad erstellen:

Location locationA = new Location("point A");

locationA.setLatitude(latA);
locationA.setLongitude(lngA);

Location locationB = new Location("point B");

locationB.setLatitude(latB);
locationB.setLongitude(lngB);

float distance = locationA.distanceTo(locationB);

oder

private double meterDistanceBetweenPoints(float lat_a, float lng_a, float lat_b, float lng_b) {
    float pk = (float) (180.f/Math.PI);

    float a1 = lat_a / pk;
    float a2 = lng_a / pk;
    float b1 = lat_b / pk;
    float b2 = lng_b / pk;

    double t1 = Math.cos(a1) * Math.cos(a2) * Math.cos(b1) * Math.cos(b2);
    double t2 = Math.cos(a1) * Math.sin(a2) * Math.cos(b1) * Math.sin(b2);
    double t3 = Math.sin(a1) * Math.sin(b1);
    double tt = Math.acos(t1 + t2 + t3);

    return 6366000 * tt;
}

Versuchen Sie diesen Code. Hier haben wir zwei Längen- und Breitengrade und die Funktion selected_location.distanceTo (near_locations) gibt die Entfernung zwischen diesen Orten in Metern zurück.

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

hier ist "Entfernung" die Entfernung zwischen Standort A und Standort B (in Metern)

Es gibt nur einen Benutzerstandort, sodass Sie iterieren können. Liste der Orte in der Nähe kann die distanceTo()Funktion aufrufen , um die Entfernung zu ermitteln. Sie können sie in einem Array speichern, wenn Sie möchten.

distanceBetween()Soweit ich weiß, ist die Ausgabe für weit entfernte Orte ein WGS84-Ellipsoid.

    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 gibt die Entfernung in Metern zwischen den beiden angegebenen Standorten an. ej target.distanceTo (Ziel).

distanceBetween gibt Ihnen auch die Entfernung an, speichert die Entfernung jedoch in einem Array von float (Ergebnisse [0]). Der Arzt sagt, wenn die Ergebnisse eine Länge von 2 oder mehr haben, wird die anfängliche Peilung in den Ergebnissen gespeichert [1]. Wenn die Ergebnisse eine Länge von 3 oder mehr haben, wird das endgültige Lager in den Ergebnissen gespeichert [2].

hoffe, dass dies hilft

Ich habe distanceTo verwendet, um die Entfernung von Punkt A nach B zu ermitteln. Ich denke, das ist der richtige Weg.

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;

    }

Ich wollte mich selbst implementieren, und am Ende las ich die Wikipedia-Seite über die Großkreis-Entfernungsformel , da kein Code so lesbar war, dass ich ihn als Grundlage verwenden konnte.

C # Beispiel

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