Berechnung der Entfernung zwischen zwei geografischen Standorten

76

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.

Sonnig
quelle
Schauen Sie sich diesen Link an: stackoverflow.com/questions/5739734/… Ich hoffe, dies wird Ihnen helfen.
Dinesh Sharma
Vielen Dank für Ihre Antwort, aber ich möchte die Entfernung mit der oben genannten Methode berechnen.
Sonniger
Bitte stellen Sie klar, dass Sie uns technisch nur eine Methodensignatur gegeben haben, die nicht ausreicht, um zu wissen, wo sich die Methodendokumentation befindet. Versuchen Sie, Informationen über die enthaltende Klasse
hinzuzufügen
Stoppen Sie die Verwendung von distanceTo, da falsche Werte zurückgegeben werden: stackoverflow.com/questions/30664031/…
Karamsa
@ Karamsa, aber in Ihrem Link wird beschrieben, dass es richtig funktioniert.
CoolMind

Antworten:

187

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;
}
Karthi
quelle
Gibt dies den Abstand zwischen zwei Orten auf der Straße an?
Harsha MV
2
Nein, es gibt Verschiebung zurück (der kürzeste Abstand zwischen zwei Punkten)
Zeeshan Chaudhry
2
float pk = (float) (180/3.14169);- kleiner Rechtschreibfehler, dies ist kein Pi ... es sollte 3.141 5 9 sein oder Math.PIverwendet werden (auch MathKlasse stattdessen veraltet FloatMath). 57 positive Stimmen und niemand bemerkt? : D
snachmsm
Bestätigt jemand, ob locationA.distanceTo(locationB)die Höhe berücksichtigt wird?
Geheimes Eichhörnchen
2
Wofür ist der zweite Codeblock? Warum würdest du nicht einfach benutzen Location. distanceBetween()?
spaaarky21
16

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)

Sandeepmaaram
quelle
3

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.

Reno
quelle
Kannst du bitte vorschlagen, welches die genaue Entfernung angibt?
Paresh Mayani
3
    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);

    }
user2871325
quelle
1

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.

eOnOe
quelle
0
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;

    }
Vinay
quelle
0

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;
    }
Henrick Kakutalua
quelle