L'API Routes est actuellement en version bêta (avant la mise à disposition générale). Il est possible que les produits et fonctionnalités pré-DG présentent une compatibilité limitée, et que les modifications apportées aux produits et fonctionnalités pré-DG ne soient pas compatibles avec d'autres versions pré-DG. Les Offres de pré-DG sont couvertes par les Conditions spécifiques au service Google Maps Platform. Pour en savoir plus, consultez les descriptions des étapes de lancement.

Demander des informations sur le trafic des polylignes

L'API Routes vous permet d'obtenir des informations sur les conditions de circulation le long d'une polyligne tenant compte du trafic. Les conditions de trafic sont exprimées en termes de catégories de vitesse (NORMAL, SLOW, TRAFFIC_JAM) applicables à un intervalle donné de la polyligne de réponse. Les intervalles sont définis par les index des points de polyligne de début (inclusifs) et de fin (exclusifs) de la polyligne.

Pour en savoir plus sur les polylignes, consultez les pages suivantes:

Afficher une polyligne

Une polyligne est représentée par un objet Polyline (REST) ou Polyline (gRPC). Vous pouvez renvoyer une polyligne dans la réponse au niveau de l'itinéraire et au niveau de la section.

Contrôlez la polyligne à renvoyer à l'aide du masque de champ de réponse:

  • Au niveau de la route, renvoyez une polyligne dans la réponse en incluant routes.polyline dans le masque de champ de réponse.

  • Au niveau de la section : renvoyez une polyligne dans la réponse pour chaque section de l'itinéraire en incluant routes.legs.polyline.

Par exemple, pour renvoyer une polyligne pour l'intégralité de l'itinéraire et pour chaque section:

X-Goog-FieldMask: routes.duration,routes.distanceMeters,routes.polyline,routes.legs.polyline

Configurer le type de polyligne

Les méthodes computeRoutes (REST) et ComputeRoutes (gRPC) acceptent l'option de requête polylineEncoding pour contrôler le type de polyligne.

polylineEncoding indique comment encoder la polyligne en utilisant ENCODED_POLYLINE (par défaut), soit en utilisant l'algorithme d'encodage de polyligne, soit en GEO_JSON_LINESTRING, en utilisant le format LineString GeoJSON.

Par exemple, dans le corps de la requête:

{
  "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": "2019-10-15T15:01:23.045123456Z",
  ...
}

Informations sur le trafic retour

Vous pouvez configurer la réponse pour inclure des informations sur les péages et les restrictions de zone de trafic possibles:

RouteTravelAdvisory et RouteLegTravelAdvisory incluent un champ de tableau pour des informations sur la vitesse du trafic qui détaillent la densité du trafic. Chaque objet du tableau est représenté par un objet SpeedReadingInterval (REST) ou SpeedReadingInterval (gRPC).

Un objet SpeedReadingInterval inclut la lecture de la vitesse d'un intervalle d'itinéraire. L'intégralité du tableau d'objets couvre l'intégralité de la polyligne de l'itinéraire sans chevauchement. Le point de départ d'un intervalle spécifié est identique au point de fin de l'intervalle précédent.

Pour configurer la méthode de renvoi des informations sur le trafic avec la polyligne, utilisez le masque de champ de réponse :

  • Au niveau de la route, renvoyez toutes les informations sur le trafic dans la réponse en incluant routes.travelAdvisory dans le masque de champ de réponse. Pour ne renvoyer que l'intervalle SpeedReadingInterval, spécifiez routes.travelAdvisory.speedReadingIntervals.

  • Au niveau de la section, vous pouvez renvoyer des informations sur le trafic dans la réponse pour chaque section de la route, en incluant routes.legs.travelAdvisory.speedReadingIntervals ou routes.legs.steps.travelAdvisory.speedReadingIntervals.

Lorsque vous renvoyez des informations sur le trafic, vous obtenez généralement des informations sur la polyligne et sur le trafic dans la réponse:

X-Goog-FieldMask: routes.duration,routes.distanceMeters,routes.polyline,routes.travelAdvisory,routes.legs.polyline,routes.legs.travelAdvisory

Exemple de réponse pour une polyligne tenant compte du trafic

Dans la réponse, le trafic au niveau de la route est disponible dans routes.travelAdvisory.speedReadingIntervals. Le trafic au niveau des jambes est disponible sous routes.legs.travelAdvisory.speedReadingIntervals.

Chaque intervalle est décrit par son startPolylinePointIndex, son endPolylinePointIndex et la catégorie de vitesse correspondante. Notez que l'absence d'index de départ dans l'intervalle correspond à l'index 0 conformément aux pratiques proto3.

Les valeurs startPolylinePointIndex et endPolylinePointIndex ne sont pas toujours consécutives. Exemple :

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

Dans ce cas, les conditions de trafic étaient identiques de l'index 2 à l'index 4.

Vous trouverez ci-dessous la réponse complète:

{
  "routes": [
    {
      "legs": {
        "polyline": {
          "encodedPolyline": "}boeF~zbjVAg@EmB`GWHlD"
        },
        "travelAdvisory": {
          "speedReadingIntervals": [
            {
              "endPolylinePointIndex": 1,
              "speed": "NORMAL"
            },
            {
              "startPolylinePointIndex": 1,
              "endPolylinePointIndex": 2,
              "speed": "SLOW"
            },
            {
              "startPolylinePointIndex": 2,
              "endPolylinePointIndex": 4,
              "speed": "NORMAL"
            }
          ] 
        }
      },
      "polyline": {
        "encodedPolyline": "}boeF~zbjVAg@EmB`GWHlD"
      },
      "travelAdvisory": {
        "speedReadingIntervals": [
          {
            "endPolylinePointIndex": 1,
            "speed": "NORMAL"
          },
          {
            "startPolylinePointIndex": 1,
            "endPolylinePointIndex": 2,
            "speed": "SLOW"
          },
          {
            "startPolylinePointIndex": 2,
            "endPolylinePointIndex": 4,
            "speed": "NORMAL"
          }
        ] 
      }
    }
  ]
}

Effectuer le rendu de polylignes prenant en compte le trafic avec le SDK Maps

Nous vous recommandons d'afficher les polylignes prenant en compte le trafic sur la carte en utilisant les différentes fonctionnalités proposées par les SDK Google Maps, y compris la coloration personnalisée, les traits et les motifs le long des étirements des polylignes. Pour en savoir plus sur l'utilisation des polylignes, consultez les pages Fonctionnalités de polyligne pour Android et Fonctionnalités de polyligne pour iOS.

Exemple d'affichage des polylignes

Les utilisateurs du SDK Maps peuvent définir une logique de mappage personnalisée entre les catégories de vitesse et les schémas de rendu des polylignes. Par exemple, on peut décider d'afficher la vitesse "NORMAL" sur une ligne bleue épaisse sur la carte, tandis que la vitesse "LENTE" peut être affichée sur une ligne orange épaisse, et ainsi de suite.

Les extraits suivants ajoutent une polyligne bleue épaisse avec des segments géodésiques de Melbourne à Perth. Pour en savoir plus, consultez les sections Personnaliser des apparences (pour Android) et Personnaliser la polyligne (pour 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