Vor- und Nachteile der Haverschen Formel im Vergleich zur Google Maps API für Entfernungsberechnungen
Die genaue Berechnung von Entfernungen ist ein zentraler Bestandteil vieler geografischer und logistischer Anwendungen. Dabei stehen oft zwei Methoden im Fokus: die Haversche Formel und die Entfernungsberechnung mithilfe der Google Maps API. Doch welche Methode eignet sich für welchen Anwendungsfall, und worin liegen ihre Vor- und Nachteile?
Was ist die Haversche Formel?
Die Haversche Formel ist eine mathematische Methode zur Berechnung der kürzesten Entfernung zwischen zwei Punkten auf der Oberfläche einer Kugel. Diese Methode berücksichtigt die Krümmung der Erde, geht jedoch von einer idealisierten kugelförmigen Erde aus.
Die Formel lautet:
a = sin²(Δφ / 2) + cos(φ₁) * cos(φ₂) * sin²(Δλ / 2) c = 2 * atan2(√a, √(1-a)) d = R * c Variablenbeschreibung: • φ₁, φ₂: Breitengrade der Punkte • λ₁, λ₂: Längengrade der Punkte • R: Erdradius (ca. 6.371 km) • d: Ergebnis der Entfernung
Vorteile der Haverschen Formel 1. Unabhängigkeit: Sie benötigt nur die geografischen Koordinaten der Punkte (Breitengrad und Längengrad). 2. Effizienz: Keine externe API-Abfrage notwendig; Berechnungen können lokal durchgeführt werden. 3. Einfache Implementierung: Kann in praktisch jeder Programmiersprache leicht umgesetzt werden.
Nachteile der Haverschen Formel 1. Nur Luftlinie: Die Berechnung liefert die kürzeste Entfernung auf einer Kugel, berücksichtigt jedoch keine tatsächlichen Straßen, Hindernisse oder andere geografische Gegebenheiten. 2. Genauigkeit: Die Annahme einer perfekten Kugel führt zu leichten Abweichungen, da die Erde keine Kugel ist. Das kann im allgemeinen vernachlässigt werden, wenn wir z.B. ein Stadtgebiet betrachten wie Berlin, dann interessiert uns die Krümmung der Erde wenig. Viel schlimmer ist die Vernachlässigung der Straßenführung.
Wie funktioniert die Entfernungsberechnung in der Google Maps API?
Die Google Maps API verwendet eine komplexere Methodik zur Berechnung von Entfernungen. Dabei werden reale Straßennetze, Verkehrsdaten und andere Faktoren berücksichtigt, um die tatsächlich benötigte Strecke und Zeit zu ermitteln. 1. Schritt 1: Übermittlung der Koordinaten und Route per API-Call. 2. Schritt 2: Berechnung der Entfernung und/oder Dauer anhand von Straßendaten, Verkehrsbedingungen und anderen Faktoren. 3. Schritt 3: Rückgabe detaillierter Daten, z. B. Entfernung, Dauer und Streckenführung.
Vorteile der Google Maps API 1. Reale Entfernungen: Liefert die tatsächliche Strecke basierend auf Straßen- und Verkehrsdaten. 2. Zusätzliche Informationen: Neben der Entfernung auch Zeitdauer, Wegbeschreibungen und Verkehrsinformationen verfügbar. 3. Hohe Genauigkeit: Ideal für Routenplanung und logistische Anwendungen.
Nachteile der Google Maps API 1. Kosten: Ab einer bestimmten Anzahl an Anfragen können Gebühren anfallen. 2. Abhängigkeit von externen Diensten: Funktioniert nur mit einer stabilen Internetverbindung. 3. Komplexität: Die Integration erfordert API-Schlüssel und ein grundlegendes Verständnis der API-Dokumentation.
Um die Google Maps API nutzen zu können, benötigen wir einen API-Schlüssel, den wir in der Google Cloud Console erstellen. Dieser Schlüssel ermöglicht den Zugriff auf verschiedene Dienste, darunter die Distance Matrix API oder die Directions API.
- Beispiel: Entfernungsmessung mit der Directions API
Die Directions API eignet sich hervorragend, um Entfernungen zwischen mehreren Punkten zu berechnen. Hier ein Beispiel:
API-Aufruf
Der Aufruf erfolgt durch eine URL wie diese: https://maps.googleapis.com/maps/api/directions/json?origin=52.515956,13.388512&destination=52.4981845,13.4610157&waypoints=52.520008,13.404954|52.529407,13.397634&key=DEIN_API_KEY
• origin: Startpunkt
• destination: Zielpunkt
• waypoints: Zwischenstationen, durch | getrennt
• key: Der API-Schlüssel
Der Rückgabewert der API ist ein JSON-Objekt. Dieses JSON enthält Details zur Route, darunter Entfernungen, Fahrzeiten und Wegbeschreibungen.
Aufruf:
<?php
// API-Schlüssel
$apiKey = 'DEIN_API_KEY';
// Parameter
$origin = '52.515956,13.388512';
$destination = '52.4981845,13.4610157';
$waypoints = '52.520008,13.404954|52.529407,13.397634';
// API-URL zusammenbauen
$url = "https://maps.googleapis.com/maps/api/directions/json?" .
"origin=" . urlencode($origin) .
"&destination=" . urlencode($destination) .
"&waypoints=" . urlencode($waypoints) .
"&key=" . $apiKey;
// API-Anfrage
$response = file_get_contents($url);
$data = json_decode($response, true);
// Ausgabe der Entfernungen
if ($data['status'] === 'OK') {
foreach ($data['routes'][0]['legs'] as $leg) {
echo "Start: " . $leg['start_address'] . "\\n";
echo "Ziel: " . $leg['end_address'] . "\\n";
echo "Entfernung: " . $leg['distance']['text'] . "\\n";
echo "Dauer: " . $leg['duration']['text'] . "\\n";
echo "-----------------\\n";
}
} else {
echo "Fehler: " . $data['status'];
}
?>
Die JSON Rückgabe würde so aussehen:
{
"status": "OK",
"routes": [
{
"legs": [
{
"start_address": "Berlin Hauptbahnhof, Berlin, Germany",
"end_address": "Alexanderplatz, Berlin, Germany",
"distance": {
"text": "3.4 km",
"value": 3400
},
"duration": {
"text": "10 mins",
"value": 600
}
},
{
"start_address": "Alexanderplatz, Berlin, Germany",
"end_address": "Brandenburger Tor, Berlin, Germany",
"distance": {
"text": "2.1 km",
"value": 2100
},
"duration": {
"text": "7 mins",
"value": 420
}
}
],
"summary": "Route through Berlin",
"bounds": {
"northeast": {
"lat": 52.531677,
"lng": 13.40732
},
"southwest": {
"lat": 52.49677,
"lng": 13.37889
}
}
}
]
}
Erklärung der JSON-Felder • status: Gibt den Status der API-Abfrage zurück. Hier ist der Wert “OK”, was bedeutet, dass die Anfrage erfolgreich war. • routes: Enthält eine Liste von möglichen Routen. Jede Route hat Details wie die legs, summary, und bounds. • legs: Repräsentiert einzelne Abschnitte einer Route (z. B. von einem Waypoint zum nächsten). • start_address: Startpunkt dieses Abschnitts. • end_address: Endpunkt dieses Abschnitts. • distance: Entfernung in Text (text) und in Metern (value). • duration: Geschätzte Fahrzeit in Text (text) und in Sekunden (value). • summary: Eine kurze Beschreibung der Route. • bounds: Geografische Grenzen der Route, definiert durch northeast und southwest Ecken.
In FileMaker kannst du JSON-Daten mit den eingebauten JSON-Funktionen verarbeiten. Über ein Insert from URL, so in der Art: Setzte Variable $$URL Wert https://maps.googleapis.com/maps/api/directions/json?origin=Berlin&destination=Munich&key=DEIN_API_KEY
Flexibler wird das ganze natürlich wenn ich die URL schon als Variable vorliegen habe, aber das ist abhängig von der Art und Weise des Entwicklers. Die Antwort (Ziel) speichern wir in einer Variablen z.B. $$JSON
Nun könnten wir diesen Bereich auslesen:
{
"routes": [
{
"legs": [
{
"start_address": "Berlin Hauptbahnhof, Berlin, Germany",
"end_address": "Alexanderplatz, Berlin, Germany",
"distance": {
"text": "3.4 km",
"value": 3400
},
"duration": {
"text": "10 mins",
"value": 600
}
}
]
}
]
}
Variable setzen $start = Wert gleich JSONGetElement ( $json ; “routes[0].legs[0].start_address” )
Variable setzen $distance = Wert gleich JSONGetElement ( $json ; “routes[0].legs[0].distance.text” )
Das über eine Schleife durch alle Elemente der JSON Rückantwort. Die weitere Verarbeitung ist dann an den Zweck gebunden.
Set Variable [ $i ; Value: 0 ]
Set Variable [ $legsCount ; Value: JSONListKeys ( $json ; "routes[0].legs" ) ]
Loop
Exit Loop If [ $i ≥ $legsCount ]
Set Variable [ $startAddress ; JSONGetElement ( $json ; "routes[0].legs[" & $i & "].start_address" ) ]
Set Variable [ $endAddress ; JSONGetElement ( $json ; "routes[0].legs[" & $i & "].end_address" ) ]
Set Variable [ $distance ; JSONGetElement ( $json ; "routes[0].legs[" & $i & "].distance.text" ) ]
Set Variable [ $duration ; JSONGetElement ( $json ; "routes[0].legs[" & $i & "].duration.text" ) ]
New Record/Request
Set Field [ Tabelle::StartAdresse ; $startAddress ]
Set Field [ Tabelle::ZielAdresse ; $endAddress ]
Set Field [ Tabelle::Entfernung ; $distance ]
Set Field [ Tabelle::Dauer ; $duration ]
Set Variable [ $i ; $i + 1 ]
End Loop
Das Fazit. Die Google Maps API und die Haversche Formel sind zwei leistungsfähige Werkzeuge zur Entfernungsberechnung. Während die Haversche Formel durch ihre Einfachheit punktet, liefert die Google Maps API präzisere Ergebnisse für reale Anwendungsfälle. Die Wahl hängt letztlich von den Anforderungen an Genauigkeit und Komplexität ab. Ich persönlich nutze die Haversche Formel gern um schon eine Vorauswahl der zu übertragenden Werte zu treffen. Dann muss ich keine 100 Geo-Daten an die Maps API übertragen, es reichen auch 10.
