Berechnung der Entfernung zwischen zwei geografischen Orten

Lesezeit: 6 Minuten

Berechnung der Entfernung zwischen zwei geografischen Orten
Sonnig

bitte bringen Sie etwas Licht in diese Situation

Im Moment habe ich zwei Arrays mit Breiten- und Längengrad von Orten in der Nähe und habe auch den Breiten- und Längengrad des Benutzerstandorts. Jetzt möchte ich die Entfernung zwischen dem Benutzerstandort und nahe gelegenen Orten berechnen und sie in der Listenansicht anzeigen.

Ich weiß, dass es eine Methode zur Entfernungsberechnung gibt

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

Nun ist das Problem, wie man diese beiden Arrays mit nahegelegenen Breiten- und Längengraden in dieser Methode passieren und das Array von Entfernungen erhalten kann.

  • Schauen Sie sich diesen Link an: stackoverflow.com/questions/5739734/… Ich hoffe, das wird Ihnen helfen.

    – Dinesh Sharma

    8. November 2011 um 11:34 Uhr

  • Danke für Ihre Antwort, aber ich möchte die Entfernung mit der obigen Methode berechnen.

    – Sonnig

    8. November 2011 um 11:45 Uhr

  • Bitte klären Sie, technisch gesehen haben Sie uns nur eine Methodensignatur gegeben, die nicht ausreicht, um zu wissen, wo die Methodendokumentation zu finden ist. Versuchen Sie, Informationen über die enthaltende Klasse hinzuzufügen

    – Murmeltier

    8. November 2011 um 12:19 Uhr

  • Beenden Sie die Verwendung von distanceTo, da es falsche Werte zurückgibt: stackoverflow.com/questions/30664031/…

    – Karamsa

    5. Juni 2015 um 10:18 Uhr

  • @Karamsa, aber in deinem Link wird beschrieben, dass es richtig funktioniert.

    – CoolMind

    5. Juni 2019 um 15:46 Uhr


Berechnung der Entfernung zwischen zwei geografischen Orten
Karthi

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

Sehen Sie sich distanceTo an

Gibt die ungefähre Entfernung in Metern zwischen diesem Standort und dem angegebenen Standort zurück. Die Entfernung wird mithilfe des WGS84-Ellipsoids definiert.

oder AbstandBetween

Berechnet die ungefähre Entfernung in Metern zwischen zwei Positionen und optional die Anfangs- und Endpeilung des kürzesten Pfads zwischen ihnen. Distanz und Peilung werden mit dem Ellipsoid WGS84 definiert.

Sie können ein Location-Objekt aus 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;
}

  • Gibt dies die Entfernung zwischen zwei Orten auf der Straße an?

    – Harsha MV

    29. Januar 2013 um 17:27 Uhr

  • nein, es gibt die Verschiebung zurück (die kürzeste Entfernung zwischen zwei Punkten)

    – Zeeshan Chaudhry

    20. Februar 2013 um 11:04 Uhr

  • float pk = (float) (180/3.14169); – kleiner Rechtschreibfehler, das ist nicht Pi… es sollte 3.141 sein59 bzw Math.PI gebraucht (auch Math Klasse stattdessen veraltet FloatMath). 57 Upvotes und niemand hat es bemerkt? 😀

    – snachmsm

    18. September 2015 um 7:40 Uhr

  • Jeder bestätigt, ob locationA.distanceTo(locationB) berücksichtigt die Höhe?

    – Geheimes Eichhörnchen

    23. Februar 2016 um 10:25 Uhr


  • Wofür ist der zweite Codeblock? Warum würdest du nicht einfach verwenden Location. distanceBetween()?

    – spaaarky21

    4. Mai 2016 um 20:19 Uhr

Berechnung der Entfernung zwischen zwei geografischen Orten
sandeepmaaram

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 “Distanz” ist die Entfernung zwischen StandortA und StandortB (in Meters)

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

Von dem, was ich verstehe, distanceBetween() ist für weit entfernte Orte, seine Ausgabe ist ein WGS84-Ellipsoid.

  • Können Sie bitte vorschlagen, welche die genaue Entfernung liefert?

    – Gemeinde Mayani

    18. Juli 2012 um 13:44 Uhr

    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 Ihnen die Entfernung in Metern zwischen den beiden angegebenen Orten ej target.distanceTo(destination).

distanceBetween gibt Ihnen auch die Entfernung, aber es speichert die Entfernung in einem Array von Float(-Ergebnissen[0]). Das Dokument 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 die endgültige Peilung in den Ergebnissen gespeichert[2]

hoffe das hilft

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

1646311388 413 Berechnung der Entfernung zwischen zwei geografischen Orten
Wein

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;

    }

1646311389 410 Berechnung der Entfernung zwischen zwei geografischen Orten
Henrick Kakutalua

Ich wollte das selbst umsetzen, ich las schließlich die Wikipedia-Seite weiter Formel für die Entfernung des Großkreisesweil kein Code lesbar genug war, um ihn als Grundlage zu verwenden.

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

923490cookie-checkBerechnung der Entfernung zwischen zwei geografischen Orten

This website is using cookies to improve the user-friendliness. You agree by using the website further.

Privacy policy