Solicitar polilinhas do trajeto

O método computeRoutes (REST) e as ComputeRoutes (gRPC) retornam a rota representada por uma polilinha como parte do resposta. Essas APIs retornam dois tipos de polilinhas:

  • Polilinha básica (padrão), representa um trajeto, mas sem trânsito. informações incorporadas na polilinha. Solicitações que retornam uma polilinha básica são cobradas de acordo com a taxa básica do Routes. Saiba mais sobre faturamento da API Routes.

  • Polilinha com reconhecimento de trânsito, que contém informações sobre as condições de trânsito. ao longo do trajeto. As condições de trânsito são expressas em termos de velocidade categorias (NORMAL, SLOW, TRAFFIC_JAM) aplicáveis em um determinado intervalo da polilinha. As solicitações de polilinhas com reconhecimento de tráfego são cobradas no Taxa preferencial de rotas. Saiba mais sobre o faturamento de API Routes. Para mais detalhes, consulte Configurar a qualidade da polilinha

Para saber mais sobre polilinhas, consulte:

Solicitar uma polilinha básica para um trajeto, trecho ou etapa

Uma polilinha é representada por um Polyline (REST) ou objeto Polyline (gRPC). Você pode retornar uma polilinha na resposta no nível do trajeto, do trecho e da etapa.

Especifique qual polilinha retornar usando o máscara do campo de resposta:

  • No nível do trajeto, retorne uma polilinha na resposta incluindo routes.polyline na máscara do campo de resposta.

  • No nível do trecho, retorna uma polilinha na resposta para cada trecho do de rota incluindo routes.legs.polyline.

  • No nível da etapa, retorna uma polilinha na resposta para cada etapa do o trecho incluindo routes.legs.steps.polyline.

Por exemplo, para retornar uma polilinha para o trajeto inteiro, para cada trecho e para cada etapa de cada trecho:

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'

Essa solicitação retorna a seguinte resposta, que inclui a polilinha dos trajeto, para cada trecho do trajeto e para cada etapa do trecho:

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

Como essa solicitação contém apenas uma origem e um destino, o valor retornado trajeto contém apenas um trecho. Portanto, a polilinha do trecho e para o trajeto são os mesmos.

Se você adicionar um waypoint intermediário à solicitação, o o trajeto contém dois trechos:

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'

Essa solicitação retorna dois trechos, cada um com uma polilinha exclusiva, e uma polilinha para todo o trajeto:

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

Qualidade da polilinha

A qualidade de uma polilinha pode ser descrita nos seguintes termos:

  • A precisão de ponto flutuante dos pontos

    Os pontos são especificados como valores de latitude e longitude, que são representados em formato de ponto flutuante de precisão única. Isso funciona bem para valores pequenos, (que pode ser representado com precisão), mas a precisão diminui à medida que os valores aumentam devido a erros de arredondamento de ponto flutuante.

    Em computeRoutes método (REST) e ComputeRoutes e isso é controlado por polylineEncoding.

  • O número de pontos que compõem a polilinha

    Quanto mais pontos houver, mais suave será a polilinha (especialmente em ou curvas).

    Em computeRoutes método (REST) e ComputeRoutes e isso é controlado por polylineQuality.

Configurar o tipo de codificação da polilinha

Use a opção de solicitação polylineEncoding para controlar o tipo de polilinha. A propriedade polylineEncoding controla se a polilinha será codificada como ENCODED_POLYLINE (padrão), ou seja, Formato do algoritmo de polilinhas codificadas será usado, ou GEO_JSON_LINESTRING, que significa que Formato LineString GeoJSON será usado.

Por exemplo, no corpo da solicitação:

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'

Configurar a qualidade da polilinha

polylineQuality especifica a qualidade da polilinha como HIGH_QUALITY ou OVERVIEW (padrão). Com OVERVIEW, a polilinha é composta usando um pequeno número de pontos e tem uma latência de solicitação menor do que HIGH_QUALITY.

Por exemplo, no corpo da solicitação:

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

Solicitar uma polilinha com reconhecimento de tráfego

Os exemplos mostrados acima de todos retornam polilinhas básicas, ou seja, polilinhas sem informações de trânsito. Além disso, você também pode solicitar que a polilinha contenha informações de trânsito para o trajeto e para cada trecho do trajeto.

As polilinhas com reconhecimento de trânsito contêm informações sobre as condições de trânsito ao longo ao longo do trajeto. As condições de trânsito são expressas em termos de categorias de velocidade (NORMAL, SLOW, TRAFFIC_JAM) para um determinado intervalo da resposta polilinha. Os intervalos são definidos pelos índices do intervalo inicial (inclusivo) e pontos finais (exclusivos).

Por exemplo, a resposta a seguir mostra o tráfego NORMAL entre a polilinha pontos 2 e 4:

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

Para fazer uma solicitação para calcular uma polilinha com reconhecimento de tráfego, defina o seguinte: na solicitação:

  • Defina o campo de matriz extraComputations como TRAFFIC_ON_POLYLINE para ativar do cálculo de tráfego.

  • Defina a travelMode como DRIVE ou TWO_WHEELER. Solicitações de outros tipos meio de transporte retornam um erro.

  • Especifique o roteamento TRAFFIC_AWARE ou TRAFFIC_AWARE_OPTIMAL preferência na solicitação. Para mais informações, consulte Configurar qualidade x latência.

  • Defina uma máscara de campo de resposta que especifique para retornar as propriedades da resposta:

    • No nível do trajeto, retorna todas as informações da viagem na resposta incluindo routes.travelAdvisory na máscara do campo de resposta. De volta apenas as informações de trânsito, especificar routes.travelAdvisory.speedReadingIntervals

    • No nível do trecho, retorna todas as informações de viagem na resposta para cada trecho do trajeto incluindo routes.legs.travelAdvisory. De volta apenas as informações de trânsito, especificar 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'

Exemplo de resposta para uma polilinha com reconhecimento de tráfego

Na resposta, os dados de trânsito são codificados na polilinha e contidos no Campo travelAdvisory, do tipo RouteLegTravelAdvisory objeto (cada trecho) e Objeto RouteTravelAdvisory (rota).

Exemplo:

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

Tanto RouteTravelAdvisory quanto RouteLegTravelAdvisory incluem um campo de matriz. chamado speedReadingIntervals, que contém informações de velocidade do trânsito. Cada na matriz é representado por uma SpeedReadingInterval (REST) ou SpeedReadingInterval (gRPC).

Um objeto SpeedReadingInterval inclui leitura de velocidade para um intervalo de trajeto. como NORMAL, SLOW ou TRAFFIC_JAM. Toda a matriz de objetos abrange a polilinha inteira do trajeto sem sobreposição. O ponto inicial de um determinado é igual ao ponto final do intervalo anterior.

Cada intervalo é descrito por startPolylinePointIndex. endPolylinePointIndex e a categoria de velocidade correspondente. Observe que a falta do índice inicial no intervalo corresponde ao índice 0 de acordo com o práticas do proto3.

Os valores startPolylinePointIndex e endPolylinePointIndex não são sempre consecutivas. Exemplo:

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

Nesse caso, as condições de tráfego foram as mesmas do índice 2 ao índice 4.

Renderizar polilinhas com reconhecimento de tráfego usando o SDK do Maps

Recomendamos a exibição de polilinhas cientes de trânsito no mapa usando os vários oferecidos pelos SDKs do Google Maps, incluindo cores personalizadas, traços e ao longo dos alongamentos da polilinha. Para mais detalhes sobre o uso de polilinhas, ver Recursos de polilinhas para Android e Recursos de polilinha para iOS.

Exemplo de renderização de polilinha

Os usuários do SDK do Maps têm a oportunidade de definir um mapeamento personalizado a lógica entre as categorias de velocidade e os esquemas de renderização de polilinhas. Como por exemplo, exibir "NORMAL" velocidade como uma linha azul grossa no no mapa enquanto estiver "SLOW" a velocidade pode ser exibida como uma linha laranja grossa, por exemplo.

Os snippets a seguir adicionam um polígono azul espesso com segmentos geodésicos de de Melbourne a Perth. Para mais informações, consulte Como personalizar aparências (para Android) e Personalizar a polilinha (para 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