Richiedi polilinee percorso

Il metodo computeRoutes (REST) e il metodo ComputeRoutes (gRPC) restituiscono entrambi la route rappresentata da una polilinea come parte la risposta corretta. Queste API restituiscono due tipi di polilinee:

  • Polilinea di base (predefinita), rappresenta una route ma senza traffico informazioni incorporate nella polilinea. Richieste che restituiscono una polilinea di base vengono fatturati alla tariffa di Routes Basic. Scopri di più su fatturazione per l'API Routes.

  • Polilinea sensibile al traffico, che contiene informazioni sulle condizioni del traffico. lungo il percorso. Le condizioni del traffico sono espresse in termini di velocità categorie (NORMAL, SLOW, TRAFFIC_JAM) applicabili in un determinato intervallo della polilinea. Le richieste di polilinee sensibili al traffico vengono fatturate Tariffa preferita di Routes. Scopri di più sulla fatturazione per API Routes. Per maggiori dettagli, vedi Configurare la qualità della polilinea

Per ulteriori informazioni sulle polilinee, vedi:

Richiedere una polilinea di base per un percorso, una tratta o un passo

Una polilinea è rappresentata da un Polyline (REST) o Oggetto Polyline (gRPC). Puoi restituire una polilinea nella risposta a livello di percorso, tratto e passo.

Specifica quale polilinea restituire utilizzando il metodo maschera del campo di risposta:

  • A livello di route, per restituire una polilinea nella risposta includi routes.polyline nella maschera del campo di risposta.

  • A livello di gamba, restituisce una polilinea nella risposta per ogni gamba del percorso includendo routes.legs.polyline.

  • A livello di passaggio, restituisce una polilinea nella risposta per ogni passaggio di della gamba includendo routes.legs.steps.polyline.

Ad esempio, per restituire una polilinea per l'intero percorso, per ogni tratto e per ogni passo di ogni gamba:

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'

Questa richiesta restituisce la seguente risposta, che include la polilinea per percorso, per ogni tratto del percorso e per ogni tappa:

{
  "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_@@_@?"
      }
    }
  ]
}

Poiché questa richiesta contiene solo un'origine e una destinazione, percorso contiene un solo tratto. Pertanto, la polilinea di una gamba e per il percorso sono le stesse.

Se aggiungi una tappa intermedia alla richiesta, il valore il percorso è costituito da due tratti:

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'

Questa richiesta restituisce due tratti, ognuno con una polilinea univoca e una polilinea per l'intero percorso:

{
  "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"
      }
    }
  ]
}

Qualità dei polilinea

La qualità di una polilinea può essere descritta nei seguenti termini:

  • La precisione con rappresentazione in virgola mobile dei punti

    I punti sono specificati come valori di latitudine e longitudine, rappresentati in formato rappresentazione in virgola mobile a precisione singola. Questo approccio è ideale per valori ridotti (che può essere rappresentato con precisione), ma la precisione diminuisce man mano che i valori a causa di errori di arrotondamento con rappresentazione in virgola mobile.

    Nella computeRoutes (REST) e ComputeRoutes dipende da polylineEncoding.

  • Il numero di punti che compongono la polilinea

    Maggiore è il numero di punti, più fluida sarà la polilinea (soprattutto nelle ).

    Nella computeRoutes (REST) e ComputeRoutes dipende da polylineQuality.

Configura tipo di codifica polilinea

Utilizza l'opzione di richiesta polylineEncoding per controllare il tipo di polilinea. La proprietà polylineEncoding consente di stabilire se la poliline viene codificata come ENCODED_POLYLINE (predefinito), che indica che Formato dell'algoritmo polilinea codificato verrà utilizzato oppure GEO_JSON_LINESTRING, che indica che Formato LineString GeoJSON .

Ad esempio, nel corpo della richiesta:

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'

Configura la qualità di Polyline

polylineQuality specifica la qualità della polilinea come HIGH_QUALITY o OVERVIEW (predefinito). Con OVERVIEW, la polilinea è composta da una piccola di punti e ha una latenza di richiesta inferiore a HIGH_QUALITY.

Ad esempio, nel corpo della richiesta:

{
  "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",
  ...
}

Richiedere una polilinea sensibile al traffico

Gli esempi mostrati sopra restituiscono polilinee di base, ovvero le polilinee senza informazioni sul traffico. Inoltre, puoi anche richiedere che la polilinea contenga informazioni sul traffico per il percorso e per ogni tappa del percorso.

Le polilinee sensibili al traffico contengono informazioni sulle condizioni del traffico lungo lungo il percorso. Le condizioni del traffico sono espresse in termini di categorie di velocità (NORMAL, SLOW, TRAFFIC_JAM) per un determinato intervallo di risposta polilinea. Gli intervalli sono definiti dagli indici iniziali (inclusi) e punti delle polilinee finali (esclusivi).

Ad esempio, la seguente risposta mostra il traffico NORMAL tra la polilinea punti 2 e 4:

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

Per effettuare una richiesta per calcolare una polilinea sensibile al traffico, imposta quanto segue proprietà nella richiesta:

  • Imposta il campo array extraComputations su TRAFFIC_ON_POLYLINE per abilitare il calcolo del traffico.

  • Imposta travelMode su DRIVE o TWO_WHEELER. Richieste per qualsiasi altro modalità di viaggio restituisce un errore.

  • Specifica il routing TRAFFIC_AWARE o TRAFFIC_AWARE_OPTIMAL nella richiesta. Per ulteriori informazioni, consulta Configurare il confronto tra qualità per minimizzare la latenza.

  • Imposta una maschera del campo di risposta che specifichi di restituire le proprietà della risposta:

    • A livello di percorso, restituisci tutte le informazioni di viaggio nella risposta entro il incluso routes.travelAdvisory nella maschera del campo di risposta. Da restituire solo le informazioni sul traffico, routes.travelAdvisory.speedReadingIntervals

    • A livello di gamba, restituisce tutte le informazioni di viaggio nella risposta per per tratto del percorso, includendo routes.legs.travelAdvisory. Da restituire solo le informazioni sul traffico, routes.legs.travelAdvisory.speedReadingIntervals.

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'

Esempio di risposta per una polilinea sensibile al traffico

Nella risposta, i dati sul traffico sono codificati nella polilinea e sono contenuti nel Campo travelAdvisory, di tipo RouteLegTravelAdvisory (ogni gamba) e Oggetto RouteTravelAdvisory (route).

Ad esempio:

{
  "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"
          }
        ] 
      }
    }
  ]
}

Sia RouteTravelAdvisory che RouteLegTravelAdvisory includono un campo array chiamato speedReadingIntervals, che contiene informazioni sulla velocità del traffico. Ciascuna dell'array è rappresentato da un SpeedReadingInterval (REST) o SpeedReadingInterval (gRPC).

Un oggetto SpeedReadingInterval include la lettura della velocità per un intervallo di percorso, come NORMAL, SLOW o TRAFFIC_JAM. L'intero array di oggetti copre l'intera polilinea del percorso senza sovrapporsi. Il punto di partenza di un è uguale al punto finale dell'intervallo precedente.

Ogni intervallo è descritto dal suo startPolylinePointIndex, endPolylinePointIndex e la corrispondente categoria di velocità. Nota che la mancanza di un indice iniziale nell'intervallo corrisponde a un indice 0 in conformità con proto3.

I valori startPolylinePointIndex e endPolylinePointIndex non sono sempre consecutiva. Ad esempio:

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

In questo caso, le condizioni del traffico erano le stesse dall'indice 2 all'indice 4.

Rendering delle polilinee sensibili al traffico con Maps SDK

Ti consigliamo di visualizzare sulla mappa le polilinee sensibili al traffico utilizzando i vari funzionalità offerte dagli SDK di Google Maps, tra cui colori, tratto e motivi lungo l'estensione della polilinea. Per ulteriori dettagli sull'uso delle polilinee, vedi Funzionalità di Polyline per Android e Funzionalità di Polyline per iOS.

Esempio di rendering polilinea

Gli utenti di Maps SDK hanno l'opportunità di definire una mappatura personalizzata tra le categorie di velocità e gli schemi di rendering delle polilinee. Come esempio, si potrebbe decidere di visualizzare "NORMALE" velocità come una spessa linea blu sulla mappa mentre "LENTO" potrebbe essere visualizzata come una spessa linea arancione, ad esempio.

I seguenti snippet aggiungono una polilinea blu spessa con segmenti geodetici da da Melbourne a Perth. Per ulteriori informazioni, vedi Personalizzazione dell'aspetto (per Android) e Personalizzare la polilinea (per 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