Ronny Schrader

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.

2. 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.

In der heutigen digitalen Arbeitswelt spielen nahtlose Integrationen zwischen verschiedenen Systemen eine entscheidende Rolle. Besonders bei der Optimierung von Routen für Außendienstmitarbeiter oder Logistikunternehmen ist es wichtig, sowohl Zeit als auch Kosten zu sparen. Dieser Blog-Post zeigt, wie man Google Maps für die dynamische Routenplanung nutzt und gleichzeitig Daten in FileMaker integriert.

Das Problem

Viele Unternehmen stehen vor der Herausforderung, eine Vielzahl von Wegpunkten (Aufträgen) optimal zu sortieren, um eine effiziente Route zu erstellen. Dies erfordert Tools, die nicht nur Kartenansichten bereitstellen, sondern auch die Reihenfolge der Stopps optimieren und diese Informationen zurück an das System (in diesem Fall FileMaker) senden können.

Die Lösung

Das folgende PHP-Script löst dieses Problem, indem es: 1. Google Maps API verwendet, um Wegpunkte zu optimieren. 2. Die optimierte Reihenfolge als Liste darstellt. 3. Ein FileMaker-Script auslöst, um diese Daten für weitere Prozesse zu nutzen.

Der erste Schritt steht darin die Daten die benötigt werden innerhalb von FileMaker zu sammeln. Dies ist möglich über die Erstellung einer Variable per Listenfunktion, SQL oder per Schleife. Wie auch immer die Umsetzung erfolgt, am Ende benötigen wir eine URL die wir an unser PHP-Script senden können. Enthalten sein müssen, die Geo-Daten und natürlich eindeutige IDs aus FileMaker damit diese Daten später auch wieder in FileMaker verarbeitet werden können. Eine URL sollte diesen Aufbau haben: https://dein-server.de/maps.php?json=true&origin=52.5212262,13.3340740 &destination=52.5070279,13.345529 &waypoints=52.4897075,13.3290075|52.4902317,13.355636|52.5037865,13.3271369|52.504083,13.3386575&auftrag=24501|24510|24547|24551|24573|24580&facilities=6039|1940|4540|5036|6634|6545 Diese werden dann über den FM-Befehl, -AUS URL einfügen- übergeben. Wie der Aufbau innerhalb von FileMaker funktioniert ist selbstredend. Ein WebViewer innerhalb von FileMaker muss natürlich vorhanden sein. Die Rückgabe muss an den WebViewer z.B. eine globale Variable erfolgen.

Das PHP Script:

<?php
// API-Schlüssel für Google Maps
$apiKey = 'Ihr_Google_Maps_API_Schlüssel';

// Werte aus GET-Parametern holen oder Standardwerte setzen
$origin = isset($_GET['origin']) ? $_GET['origin'] : '52.515956,13.388512';
$destination = isset($_GET['destination']) ? $_GET['destination'] : '52.4981845,13.4610157';
$waypoints = isset($_GET['waypoints']) ? $_GET['waypoints'] : '';
$auftrag = isset($_GET['auftrag']) ? explode('|', $_GET['auftrag']) : [];
$facilities = isset($_GET['facilities']) ? explode('|', $_GET['facilities']) : [];

// Wegpunkte in ein Array umwandeln
$waypointsArray = explode('|', $waypoints);
?>

1. Origin (Startpunkt)

Der Origin ist der Ausgangspunkt der Route. • Es handelt sich um die Position, von der die Route beginnt. • In der Regel wird sie als geografische Koordinate angegeben (z. B. 52.515956,13.388512 für Berlin). • Beispiel: Eine zentrale Lagerhalle oder der Startpunkt eines Fahrers.

2. Destination (Endpunkt)

Die Destination ist das Ziel der Route. • Es ist der Punkt, an dem die Route endet. • Ähnlich wie der Origin wird auch die Destination als geografische Koordinate angegeben. • Beispiel: Der Zielort eines Lieferauftrags.

3. Waypoint (Zwischenstation)

Ein Waypoint ist eine oder mehrere Zwischenstationen entlang der Route. • Es handelt sich um Orte, die der Fahrer besuchen muss, bevor er sein Ziel (Destination) erreicht. • Waypoints können ebenfalls als Koordinaten (z. B. 52.5062585,13.2845797) angegeben werden. • Sie werden oft verwendet, um Stopps bei Kunden, Lieferstationen oder Servicepunkten darzustellen. • Google Maps erlaubt, mehrere Waypoints anzugeben, um komplexe Routen zu erstellen.

Das Script liest die Parameter origin, destination, waypoints, auftrag, und facilities, um sie für die Routenplanung vorzubereiten. Diese Parameter könnten direkt aus einer FileMaker-Datenbank oder einer anderen Quelle kommen.

Die Routenoptimierung

Das Herzstück des Scripts ist die Funktion initMap():

function initMap() { const map = new google.maps.Map(document.getElementById(‘map’), { zoom: 13, center: { lat: , lng: }, });

const directionsService = new google.maps.DirectionsService();
const directionsRenderer = new google.maps.DirectionsRenderer({ map: map });

directionsService.route(
	{
		origin: locations[0].position,
		destination: locations[locations.length - 1].position,
		waypoints: locations.slice(1, -1).map(location => ({
			location: location.position,
			stopover: true,
		})),
		travelMode: google.maps.TravelMode.DRIVING,
		optimizeWaypoints: true,
	},
	(result, status) => {
		if (status === 'OK') {
			directionsRenderer.setDirections(result);
			const waypointOrder = result.routes[0].waypoint_order.map(index => locations[index + 1].label);
			optimizedOrder = [locations[0].label, ...waypointOrder, locations[locations.length - 1].label];
		} else {
			console.error('Error:', status);
		}
	}
);

}

Die Funktion ruft die Google Maps Directions API auf, um die optimale Reihenfolge der Wegpunkte zu berechnen. Diese Reihenfolge wird in optimizedOrder gespeichert.

Integration mit FileMaker

Das Script enthält einen Button, der die optimierte Reihenfolge an ein FileMaker-Script übergibt:

function sendToFileMaker() { if (optimizedOrder.length > 0) { const filemakerUrl = fmp://$/DEINE_DATEI?script=(0002)_Planung_Direkt_aus_Maps_holen&param=${encodeURIComponent(optimizedOrder.join('\n'))}; window.location.href = filemakerUrl; } else { alert(‘Die Route ist noch nicht optimiert. Bitte warten.'); } }

Dieser Button ermöglicht es, die optimierten Daten direkt in FileMaker zu laden, wo sie für weitere Aktionen wie die Gruppierung von Aufträgen oder Berichte verwendet werden können.

Vorteile der Lösung 1. Zeitersparnis: Die API optimiert die Route automatisch. 2. Nahtlose Integration: Die Übergabe an FileMaker erfolgt reibungslos. 3. Flexibilität: Die Darstellung in der Karte ermöglicht eine visuelle Kontrolle der Route. 4. Erweiterbarkeit: Zusätzliche Funktionen wie das Hinzufügen von z.B. Anlagen können leicht integriert werden.

Fazit

Dieses Script ist eine effektive Lösung für Unternehmen, die ihre Logistikprozesse optimieren möchten. Durch die Kombination von Google Maps und FileMaker wird eine leistungsstarke, flexible und leicht implementierbare Lösung geschaffen.

Als Anmerkung ist allerdings zu beachten, in diesem Fall können nur 10 Punkte verarbeitet werden. Dies erfordert eine Vorauswahl der an Google zu übergebenen Punkte. Dies kann direkt schon über die Google APIs erfolgen oder z.B. die Haversche Formel.

Zum Überblick das gesamte Script:

// Werte aus GET-Parametern holen oder Standardwerte setzen
$origin = isset($_GET['origin']) ? $_GET['origin'] : '52.515956,13.388512';
$destination = isset($_GET['destination']) ? $_GET['destination'] : '52.4981845,13.4610157';
$waypoints = isset($_GET['waypoints']) ? $_GET['waypoints'] : '';
$auftrag = isset($_GET['auftrag']) ? explode('|', $_GET['auftrag']) : [];
$facilities = isset($_GET['facilities']) ? explode('|', $_GET['facilities']) : [];

// Wegpunkte in ein Array umwandeln um Anzeige über PIN
$waypointsArray = explode('|', $waypoints);
?>

<!DOCTYPE html>
<html>
<head>
    <title>Dynamische Route</title>
    <script src="https://maps.googleapis.com/maps/api/js?key=DEIN_API_KEY"></script>
    <script>
        let optimizedOrder = []; // Variable für die optimierte Reihenfolge

        function initMap() {
            // Initialisiere die Karte
            const map = new google.maps.Map(document.getElementById('map'), {
                zoom: 13,
                center: { lat: <?php echo explode(',', $origin)[0]; ?>, lng: <?php echo explode(',', $origin)[1]; ?> },
            });

            const locations = [
                { 
                    position: { lat: <?php echo explode(',', $origin)[0]; ?>, lng: <?php echo explode(',', $origin)[1]; ?> },
                    label: '<?php echo $auftrag[0] ?? "Start"; ?>',
                    facilities: '<?php echo $facilities[0] ?? "Keine Anlagen"; ?>',
                },
                <?php foreach ($waypointsArray as $index => $point): ?>
                { 
                    position: { lat: <?php echo explode(',', $point)[0]; ?>, lng: <?php echo explode(',', $point)[1]; ?> },
                    label: '<?php echo $auftrag[$index + 1] ?? "Waypoint"; ?>',
                    facilities: `<?php echo str_replace(',', '<br>', $facilities[$index + 1] ?? "Keine Anlagen"); ?>`,
                },
                <?php endforeach; ?>
                { 
                    position: { lat: <?php echo explode(',', $destination)[0]; ?>, lng: <?php echo explode(',', $destination)[1]; ?> },
                    label: '<?php echo $auftrag[count($auftrag) - 1] ?? "Ziel"; ?>',
                    facilities: '<?php echo $facilities[count($facilities) - 1] ?? "Keine Anlagen"; ?>',
                }
            ];

            // Details zu Markern und Kreisen hinzufügen
            locations.forEach((location) => {
                const marker = new google.maps.Marker({
                    position: location.position,
                    map: map,
                    label: {
                        text: location.label,
                        color: '#000',
                        fontSize: '12px',
                        fontWeight: 'bold',
                    },
                });
            });

            map.fitBounds(bounds);
        }

        function sendToFileMaker() {
            if (optimizedOrder.length > 0) {
                const filemakerUrl = `fmp://$/DEINE_DATEI?script=Planung&param=${encodeURIComponent(optimizedOrder.join('\n'))}`;
                window.location.href = filemakerUrl;
            } else {
                alert('Die Route ist noch nicht optimiert. Bitte warten.');
            }
        }
    </script>
</head>
<body onload="initMap()">
    <div id="map" style="width: 100%; height: 80%;"></div>
    <button onclick="sendToFileMaker()">Optimierte Reihenfolge senden</button>
</body>
</html>