Erstellen von Isochronen-Karten mit OpenRouteService und Python

Was sind Isochronen-Karten und wofür sind sie nützlich?

Isochronen-Karten visualisieren, welche Gebiete innerhalb einer bestimmten Zeitspanne von einem bestimmten Punkt aus erreichbar sind. Dies ist besonders nützlich für:

• Lieferzonen (z. B. Restaurants oder Paketdienste, um zu bestimmen, welche Gebiete in einer bestimmten Zeit beliefert werden können).
• Standortanalysen (z. B. welche Kunden innerhalb von 10 Minuten mit dem Auto einen Laden erreichen können).
• Notfallplanung (z. B. welche Krankenhäuser oder Feuerwachen einen bestimmten Ort innerhalb einer bestimmten Zeit erreichen können).

In diesem Artikel zeige ich, wie man Isochronen mit OpenRouteService erstellt, verarbeitet und in KML speichert, um sie beispielsweise in SimplyDelivery oder Google Earth weiterzuverwenden.

Schritt 1: Registrierung und API-Key abrufen

Um die Isochronen-API von OpenRouteService zu nutzen, registriere dich auf openrouteservice.org und erstelle einen kostenlosen API-Schlüssel. Dieser wird für alle Anfragen benötigt.

Schritt 2: Standort bestimmen

Der erste Schritt ist die Festlegung eines Ausgangspunktes. Eine einfache Möglichkeit ist Google Maps:

1. Suche den gewünschten Standort.
2. Klicke mit der rechten Maustaste auf die Karte.
3. Wähle "Was ist hier?" und kopiere die Koordinaten.
4. Die Koordinaten haben oft viele Dezimalstellen. Runde sie auf sechs Nachkommastellen (z. B. 53.047197, 8.720864).

Schritt 3: Isochronen mit OpenRouteService abrufen

Die OpenRouteService-API ermöglicht es, Isochronen für verschiedene Zeitspannen zu erstellen. Dafür verwenden wir die API-Route:

https://api.openrouteservice.org/v2/isochrones/driving-car

Möglichkeiten zur Abfrage:

• Mit Postman: Eine POST-Anfrage an die API senden.
• Direkt im API-Playground: Hier ausprobieren.

Beispiel einer API-Anfrage (JSON-Body)

{
    "locations": [[8.720864, 53.047197]],
    "range": [300, 600, 900],
    "range_type": "time"
}

• locations: Startpunkt (Längengrad, Breitengrad).
• range: Zeiten in Sekunden (z. B. 300 = 5 Minuten, 600 = 10 Minuten, 900 = 15 Minuten).

API-Antwort: Die API liefert ein GeoJSON, das die Isochronen enthält.

Schritt 4: GeoJSON in geojson.io überprüfen

Zur Kontrolle der Daten können wir das Ergebnis in geojson.io einfügen. Dadurch können wir visuell prüfen, ob die Isochronen korrekt generiert wurden.

Schritt 5: Überschneidungen entfernen (Differenzierung der Isochronen)

Die generierten Isochronen überlappen sich, d. h., die 15-Minuten-Zone enthält auch die 10- und 5-Minuten-Zone. Um diese zu differenzieren, nutzen wir Python und Shapely:

import json
from shapely.geometry import shape
from shapely.ops import unary_union

# Lade das GeoJSON mit den Isochronen
with open("isochrones.geojson", "r", encoding="utf-8") as file:
    geojson_data = json.load(file)

isochrones = sorted(geojson_data["features"], key=lambda x: x["properties"]["value"])
differentiated_features = []
previous_polygon = None

for feature in isochrones:
    current_polygon = shape(feature["geometry"])
    diff_polygon = current_polygon if not previous_polygon else current_polygon.difference(previous_polygon)
    differentiated_features.append({"type": "Feature", "properties": feature["properties"], "geometry": json.loads(json.dumps(diff_polygon.__geo_interface__))})
    previous_polygon = current_polygon

with open("differentiated_isochrones.geojson", "w", encoding="utf-8") as output_file:
    json.dump({"type": "FeatureCollection", "features": differentiated_features}, output_file, indent=4)

print("✅ Differenzierte Isochronen gespeichert als 'differentiated_isochrones.geojson'")

Schritt 6: GeoJSON in einzelne KML-Dateien konvertieren

Jetzt speichern wir jede Zone als eigene KML-Datei:

import json
from shapely.geometry import shape
import simplekml

with open("differentiated_isochrones.geojson", "r", encoding="utf-8") as file:
    geojson_data = json.load(file)

for feature in geojson_data["features"]:
    kml = simplekml.Kml()
    geom = shape(feature["geometry"])
    name = f"Isochrone {feature['properties']['value']} Sekunden"
    
    if geom.geom_type == "Polygon":
        kml.newpolygon(name=name, outerboundaryis=list(geom.exterior.coords))
    elif geom.geom_type == "MultiPolygon":
        for poly in geom.geoms:
            kml.newpolygon(name=name, outerboundaryis=list(poly.exterior.coords))
    
    filename = f"isochrone_{feature['properties']['value']}.kml"
    kml.save(filename)
    print(f"✅ KML gespeichert: {filename}")

print("🎉 Alle Isochronen wurden als KML exportiert!")

Ergebnis:

• isochrone_300.kml (5 Minuten)
• isochrone_600.kml (10 Minuten)
• isochrone_900.kml (15 Minuten)

Schritt 7: KML für SimplyDelivery oder Google Earth nutzen

Die generierten KML-Dateien können nun weiterverwendet werden, z. B. um Lieferzonen in SimplyDelivery hochzuladen oder sie in Google Earth zu visualisieren.

---

Fazit

Mit OpenRouteService und Python haben wir: ✅ Isochronen generiert (Erreichbarkeitszonen in 5, 10 und 15 Minuten).
✅ Die Daten als GeoJSON überprüft und angepasst.
✅ Überschneidungen entfernt, damit jede Zone nur ihren eigenen Bereich enthält.
✅ Jede Zone als einzelne KML gespeichert, um sie für weitere Anwendungen zu nutzen.