Routen-Polylinien anfordern

Entwickler im Europäischen Wirtschaftsraum (EWR)

Sowohl die Methode computeRoutes (REST) als auch die Methode ComputeRoutes (gRPC) geben die Route als Polylinie in der Antwort zurück. Diese APIs geben zwei Arten von Polylinien zurück:

  • Einfache Polylinie (Standard): Stellt eine Route dar, aber ohne in die Polylinie eingebettete Verkehrsinformationen. Anfragen, die eine einfache Polylinie zurückgeben, werden zum Routes Basic-Tarif abgerechnet. Weitere Informationen zur Abrechnung für die Routes API

  • Polylinie mit Berücksichtigung der aktuellen Verkehrslage: Enthält Informationen zur Verkehrslage entlang der Route. Die Verkehrslage wird in Geschwindigkeitskategorien (NORMAL, SLOW, TRAFFIC_JAM) angegeben, die für ein bestimmtes Intervall der Polylinie gelten. Anfragen für verkehrsabhängige Polylinien werden zum Routes Preferred-Tarif abgerechnet. Weitere Informationen zur Abrechnung für die Routes API Weitere Informationen finden Sie unter Polylinienqualität konfigurieren.

Weitere Informationen zu Polylinien finden Sie hier:

Einfache Polylinie für eine Route, einen Abschnitt oder einen Schritt anfordern

Eine Polylinie wird durch ein Polyline-Objekt (REST) oder ein Polyline-Objekt (gRPC) dargestellt. Sie können eine Polylinie in der Antwort auf Routen-, Abschnitts- und Schritt-Ebene zurückgeben.

Geben Sie mit der Feldmaske für die Antwort an, welche Polylinie zurückgegeben werden soll:

  • Auf Routenebene: Geben Sie eine Polylinie in der Antwort zurück, indem Sie routes.polyline in die Antwortfeldmaske einfügen.

  • Auf Abschnittsebene: Geben Sie in der Antwort für jeden Abschnitt der Route eine Polylinie zurück, indem Sie routes.legs.polyline einfügen.

  • Auf Schrittebene: Wenn Sie routes.legs.steps.polyline angeben, wird in der Antwort für jeden Schritt des Abschnitts eine Polylinie zurückgegeben.

So geben Sie beispielsweise eine Polylinie für die gesamte Route, für jeden Abschnitt und für jeden Schritt jedes Abschnitts zurück:

curl -X POST -d '{
  "origin":{
    "address": "1600 Amphitheatre Parkway, Mountain View, CA"
  },
  "destination":{
    "address": "24 Willie Mays Plaza, San Francisco, CA 94107"
  },
  "travelMode": "DRIVE"
}' \
-H 'Content-Type: application/json' \
-H 'X-Goog-Api-Key: YOUR_API_KEY' \
-H 'X-Goog-FieldMask: routes.duration,routes.distanceMeters,routes.polyline,routes.legs.polyline,routes.legs.steps.polyline' \
'https://routes.googleapis.com/directions/v2:computeRoutes'

Diese Anfrage gibt die folgende Antwort zurück, die die Polylinie für die Route, für jeden Abschnitt der Route und für jeden Schritt des Abschnitts enthält:

{
  "routes": [
    {
      "legs": [
        {
          "polyline": {
              "encodedPolyline": "ipkcFfich...@Bs@?A?O?SD{A@o@B}@I?qA?_AA_@@_@?"
          }
        },
          "steps": [
              {
                  "polyline": {
                      "encodedPolyline": "kclcF...@sC@YIOKI"
                  }
              },
              {
                  "polyline": {
                      "encodedPolyline": "wblcF~...SZSF_@?"
                  }
              },
              ...
      ],
      "distanceMeters": 56901,
      "duration": "2420s",
      "polyline": {
        "encodedPolyline": "ipkcFfich...@Bs@?A?O?SD{A@o@B}@I?qA?_AA_@@_@?"
      }
    }
  ]
}

Da diese Anfrage nur einen Start- und einen Zielort enthält, umfasst die zurückgegebene Route nur einen Abschnitt. Daher sind die Polylinien für den Abschnitt und die Route identisch.

Wenn Sie der Anfrage einen Zwischenwegpunkt hinzufügen, enthält die zurückgegebene Route zwei Abschnitte:

curl -X POST -d '{
  "origin":{
    "address": "1600 Amphitheatre Parkway, Mountain View, CA"
  },
  "destination":{
    "address": "24 Willie Mays Plaza, San Francisco, CA 94107"
  },
  "intermediates": [
    { "address": "450 Serra Mall, Stanford, CA 94305, USA"},
  ],
  "travelMode": "DRIVE",
}' \
-H 'Content-Type: application/json' \
-H 'X-Goog-Api-Key: YOUR_API_KEY' \
-H 'X-Goog-FieldMask: routes.duration,routes.distanceMeters,routes.polyline,routes.legs.polyline' \
'https://routes.googleapis.com/directions/v2:computeRoutes'

Diese Anfrage gibt zwei Abschnitte mit jeweils einer eindeutigen Polylinie und eine Polylinie für die gesamte Route zurück:

{
  "routes": [
    {
      "legs": [
        {
          "polyline": {
            "encodedPolyline": "kclcFfqchV?A...?I@G?GAECCCEKICBAFG"
          }
          "steps": [
            {
                "polyline": {
                    "encodedPolyline": "kclcFfqch...YIOKI"
                }
            },
        ...
        },
        {
          "polyline": {
            "encodedPolyline": "ojmcFtethV?K...QOYQOGA?_@MUG[Ga@G"
          }
          "steps": [
            {
                "polyline": {
                    "encodedPolyline": "uypeFbo`jVgJq...PoBiC"
                }
            },
        ...
        }
      ],
      "distanceMeters": 68403,
      "duration": "3759s",
      "polyline": {
          "encodedPolyline": "kclcFfqchV?A?CBKF[Ha...?GAECCCEKICBAFGJEBE"
      }
    }
  ]
}

Polylinienqualität

Die Qualität einer Polylinie kann mit den folgenden Begriffen beschrieben werden:

  • Gleitkommapräzision der Punkte

    Punkte werden als Breiten- und Längengradwerte angegeben, die im Gleitkommaformat mit einfacher Genauigkeit dargestellt werden. Dies funktioniert gut für kleine Werte (die genau dargestellt werden können), aber die Genauigkeit nimmt mit zunehmenden Werten aufgrund von Gleitkomma-Rundungsfehlern ab.

    In der Methode computeRoutes (REST) und ComputeRoutes wird dies durch polylineEncoding gesteuert.

  • Anzahl der Punkte, aus denen die Polylinie besteht

    Je mehr Punkte vorhanden sind, desto glatter ist die Polylinie (insbesondere in Kurven).

    In der Methode computeRoutes (REST) und ComputeRoutes wird dies durch polylineQuality gesteuert.

Codierungstyp für Polylinien konfigurieren

Verwenden Sie die Anfrageoption polylineEncoding, um den Polylinientyp zu steuern. Mit dem Attribut polylineEncoding wird festgelegt, ob die Polylinie als ENCODED_POLYLINE (Standard) codiert wird, d. h., dass das Format des Algorithmus für codierte Polylinien verwendet wird, oder als GEO_JSON_LINESTRING, d. h., dass das GeoJSON-LineString-Format verwendet wird.

Beispiel für den Anfragetext:

curl -X POST -d '{
  "origin":{
    "address": "1600 Amphitheatre Parkway, Mountain View, CA"
  },
  "destination":{
    "address": "24 Willie Mays Plaza, San Francisco, CA 94107"
  },
  "travelMode": "DRIVE",
  "polylineEncoding": "ENCODED_POLYLINE"
}' \
-H 'Content-Type: application/json' \
-H 'X-Goog-Api-Key: YOUR_API_KEY' \
-H 'X-Goog-FieldMask: routes.duration,routes.distanceMeters,routes.polyline,routes.legs.polyline' \
'https://routes.googleapis.com/directions/v2:computeRoutes'

Polylinienqualität konfigurieren

polylineQuality gibt die Qualität der Polylinie als HIGH_QUALITY oder OVERVIEW (Standard) an. Bei OVERVIEW wird die Polylinie aus einer kleinen Anzahl von Punkten zusammengesetzt und hat eine geringere Anfragelatenz als HIGH_QUALITY.

Beispiel für den Anfragetext:

{
  "origin":{
    "location":{
      "latLng":{
        "latitude": 37.419734,
        "longitude": -122.0827784
      }
    }
  },
  "destination":{
    "location":{
      "latLng":{
        "latitude": 37.417670,
        "longitude": -122.079595
      }
    }
  },
  "travelMode": "DRIVE",
  "routingPreference": "TRAFFIC_AWARE",
  "polylineQuality": "HIGH_QUALITY",
  "polylineEncoding": "ENCODED_POLYLINE",
  "departureTime": "2023-10-15T15:01:23.045123456Z",
  ...
}

Polylinie mit Berücksichtigung der Verkehrslage anfordern

In den Beispielen oben werden einfache Polylinien zurückgegeben, d. h. Polylinien ohne Verkehrsinformationen. Außerdem können Sie anfordern, dass die Polylinie Verkehrsinformationen für die Route und für jeden Streckenabschnitt enthält.

Verkehrsabhängige Polylinien enthalten Informationen zur Verkehrslage entlang der Route. Die Verkehrslage wird in Geschwindigkeitskategorien (NORMAL, SLOW, TRAFFIC_JAM) für ein bestimmtes Intervall der Antwort-Polylinie angegeben. Die Intervalle werden durch die Indexe ihrer Start- (einschließlich) und Endpunkte (ausschließlich) der Polylinie definiert.

In der folgenden Antwort wird beispielsweise NORMAL-Verkehr zwischen den Polylinienpunkten 2 und 4 angezeigt:

{
  "startPolylinePointIndex": 2,
  "endPolylinePointIndex": 4,
  "speed": "NORMAL"
}

Wenn Sie eine Anfrage zum Berechnen einer verkehrsabhängigen Polylinie stellen möchten, legen Sie die folgenden Attribute in der Anfrage fest:

  • Setzen Sie das Array-Feld extraComputations auf TRAFFIC_ON_POLYLINE, um die Verkehrsberechnung zu aktivieren.

  • Legen Sie den Wert travelMode auf DRIVE oder TWO_WHEELER fest. Anfragen für andere Mobilitätsformen geben einen Fehler zurück.

  • Geben Sie in der Anfrage entweder die Routing-Einstellung TRAFFIC_AWARE oder TRAFFIC_AWARE_OPTIMAL an. Weitere Informationen finden Sie unter Qualität im Vergleich zur Latenz konfigurieren.

  • Legen Sie eine Antwortfeldmaske fest, die angibt, dass die Antwortattribute zurückgegeben werden sollen:

    • Auf Routenebene: Geben Sie alle Reiseinformationen in der Antwort zurück, indem Sie routes.travelAdvisory in die Antwortfeldmaske aufnehmen. Wenn Sie nur die Verkehrsinformationen zurückgeben möchten, geben Sie routes.travelAdvisory.speedReadingIntervals an.

    • Auf Abschnittsebene: Wenn Sie routes.legs.travelAdvisory einfügen, werden in der Antwort alle Reiseinformationen für jeden Abschnitt der Route zurückgegeben. Wenn Sie nur die Verkehrsinformationen zurückgeben möchten, geben Sie routes.legs.travelAdvisory.speedReadingIntervals an.

curl -X POST -d '{
  "origin":{
    "address": "1600 Amphitheatre Parkway, Mountain View, CA"
  },
  "destination":{
    "address": "24 Willie Mays Plaza, San Francisco, CA 94107"
  },
  "travelMode": "DRIVE",
  "extraComputations": ["TRAFFIC_ON_POLYLINE"],
  "routingPreference": "TRAFFIC_AWARE_OPTIMAL"
}' \
-H 'Content-Type: application/json' \
-H 'X-Goog-Api-Key: YOUR_API_KEY' \
-H 'X-Goog-FieldMask: routes.duration,routes.distanceMeters,routes.polyline,routes.legs.polyline,routes.travelAdvisory,routes.legs.travelAdvisory' \
'https://routes.googleapis.com/directions/v2:computeRoutes'

Beispielantwort für eine verkehrsabhängige Polylinie

In der Antwort werden Verkehrsdaten in der Polylinie codiert und im Feld travelAdvisory vom Typ RouteLegTravelAdvisory (jeder Abschnitt) und RouteTravelAdvisory (Route) enthalten.

Beispiel:

{
  "routes": [
    {
      "legs": {
        "polyline": {
          "encodedPolyline": "}boeF~zbjVAg@EmB`GWHlD"
        },
        // Traffic data for the leg.
        "travelAdvisory": {
          "speedReadingIntervals": [
            {
              "endPolylinePointIndex": 1,
              "speed": "NORMAL"
            },
            {
              "startPolylinePointIndex": 1,
              "endPolylinePointIndex": 2,
              "speed": "SLOW"
            },
            {
              "startPolylinePointIndex": 2,
              "endPolylinePointIndex": 4,
              "speed": "NORMAL"
            }
          ] 
        }
      },
      "polyline": {
        "encodedPolyline": "}boeF~zbjVAg@EmB`GWHlD"
      },
      // Traffic data for the route.
      "travelAdvisory": {
        "speedReadingIntervals": [
          {
            "endPolylinePointIndex": 1,
            "speed": "NORMAL"
          },
          {
            "startPolylinePointIndex": 1,
            "endPolylinePointIndex": 2,
            "speed": "SLOW"
          },
          {
            "startPolylinePointIndex": 2,
            "endPolylinePointIndex": 4,
            "speed": "NORMAL"
          }
        ] 
      }
    }
  ]
}

Sowohl RouteTravelAdvisory als auch RouteLegTravelAdvisory enthalten ein Array-Feld namens speedReadingIntervals, das Informationen zur Verkehrsgeschwindigkeit enthält. Jedes Objekt im Array wird durch ein SpeedReadingInterval-Objekt (REST) oder ein SpeedReadingInterval-Objekt (gRPC) dargestellt.

Ein SpeedReadingInterval-Objekt enthält Geschwindigkeitsmesswerte für ein Routenintervall, z. B. NORMAL, SLOW oder TRAFFIC_JAM. Das gesamte Array von Objekten deckt die gesamte Polylinie der Route ohne Überschneidungen ab. Der Startpunkt eines angegebenen Intervalls ist mit dem Endpunkt des vorherigen Intervalls identisch.

Jedes Intervall wird durch startPolylinePointIndex, endPolylinePointIndex und die entsprechende Geschwindigkeitskategorie beschrieben. Beachten Sie, dass das Fehlen eines Startindex innerhalb des Intervalls gemäß den proto3-Praktiken dem Index 0 entspricht.

Die Werte startPolylinePointIndex und endPolylinePointIndex sind nicht immer aufeinanderfolgend. Beispiel:

{
  "startPolylinePointIndex": 2,
  "endPolylinePointIndex": 4,
  "speed": "NORMAL"
}

In diesem Fall war die Verkehrslage von Index 2 bis Index 4 gleich.

Verkehrsabhängige Polylinien mit dem Maps SDK rendern

Wir empfehlen, verkehrsabhängige Polylinien auf der Karte mit den verschiedenen Funktionen der Google Maps SDKs darzustellen, einschließlich benutzerdefinierter Farben, Striche und Muster entlang der Polylinienabschnitte. Weitere Informationen zur Verwendung von Polylinien finden Sie unter Polylinien-Features für Android und Polylinien-Features für iOS.

Beispiel für das Rendern von Polylinien

Nutzer des Maps SDK können eine benutzerdefinierte Zuordnungslogik zwischen den Geschwindigkeitskategorien und den Polylinien-Renderingschemas definieren. Sie können beispielsweise festlegen, dass die Geschwindigkeit „NORMAL“ als dicke blaue Linie auf der Karte angezeigt wird, während die Geschwindigkeit „LANGSAM“ als dicke orangefarbene Linie dargestellt wird.

Mit den folgenden Snippets wird eine dicke blaue Polylinie mit geodätischen Segmenten von Melbourne nach Perth hinzugefügt. Weitere Informationen finden Sie unter Darstellung anpassen (für Android) und Polylinie anpassen (für iOS).

Android

Java

Polyline line = map.addPolyline(new PolylineOptions()
    .add(new LatLng(-37.81319, 144.96298), new LatLng(-31.95285, 115.85734))
    .width(25)
    .color(Color.BLUE)
    .geodesic(true));

Kotlin

val line: Polyline = map.addPolyline(
  PolylineOptions()
    .add(LatLng(-37.81319, 144.96298), LatLng(-31.95285, 115.85734))
    .width(25f)
    .color(Color.BLUE)
    .geodesic(true)
)

iOS

Objective-C

GMSMutablePath *path = [GMSMutablePath path];
[path addLatitude:-37.81319 longitude:144.96298];
[path addLatitude:-31.95285 longitude:115.85734];
GMSPolyline *polyline = [GMSPolyline polylineWithPath:path];
polyline.strokeWidth = 10.f;
polyline.strokeColor = .blue;
polyline.geodesic = YES;
polyline.map = mapView;

Swift

let path = GMSMutablePath()
path.addLatitude(-37.81319, longitude: 144.96298)
path.addLatitude(-31.95285, longitude: 115.85734)
let polyline = GMSPolyline(path: path)
polyline.strokeWidth = 10.0
polyline.geodesic = true
polyline.map = mapView

Codierte Polylinien mit „Entlang der Route suchen“ verwenden

Mit „Text Search (New)“ in der Places API (New) können Sie entlang einer berechneten Route suchen. Sie übergeben die codierte Polylinie einer vorab berechneten Route von Routes API Compute Routes an die Text Search (New)-Anfrage. Die Antwort enthält dann Orte, die den Suchkriterien entsprechen und sich in der Nähe der angegebenen Route befinden. Weitere Informationen finden Sie unter Entlang einer Route suchen.

So können Sie beispielsweise Cafés entlang der Route zwischen Start- und Zielort zurückgeben lassen:

Node.js

const API_KEY = 'YOUR_API_KEY';
const routes_service = 'https://routes.googleapis.com/directions/v2:computeRoutes';
const textSearch_service = 'https://places.googleapis.com/v1/places:searchText';

function init(){ const routes_request = { "origin":{ "address": "1600 Amphitheatre Parkway, Mountain View, CA" }, "destination":{ "address": "24 Willie Mays Plaza, San Francisco, CA 94107" }, "travelMode": "DRIVE" }; const textSearch_request = { "textQuery": "cafe", "searchAlongRouteParameters": { "polyline": { "encodedPolyline": "" } } }; fetchResources(routes_service,routes_request).then(routes => { textSearch_request.searchAlongRouteParameters.polyline.encodedPolyline = routes.routes[0].polyline.encodedPolyline; fetchResources(textSearch_service,textSearch_request).then(places => { console.log(places); }); }); } async function fetchResources(resource,reqBody){ const response = await fetch(resource, { method: 'POST', body: JSON.stringify(reqBody), headers: { 'Content-Type': 'application/json', 'X-Goog-Api-Key': API_KEY, 'X-Goog-FieldMask': '*' } }); const responseJSON = await response.json(); return responseJSON; } init();