Package google.maps.routeoptimization.v1

Index

• RouteOptimization (interface)
• AggregatedMetrics (message)
• BatchOptimizeToursMetadata (message)
• BatchOptimizeToursRequest (message)
• BatchOptimizeToursRequest.AsyncModelConfig (message)
• BatchOptimizeToursResponse (message)
• BreakRule (message)
• BreakRule.BreakRequest (message)
• BreakRule.FrequencyConstraint (message)
• DataFormat (enum)
• DistanceLimit (message)
• GcsDestination (message)
• GcsSource (message)
• InjectedSolutionConstraint (message)
• InjectedSolutionConstraint.ConstraintRelaxation (message)
• InjectedSolutionConstraint.ConstraintRelaxation.Relaxation (message)
• InjectedSolutionConstraint.ConstraintRelaxation.Relaxation.Level (enum)
• InputConfig (message)
• Location (message)
• OptimizeToursLongRunningMetadata (message)
• OptimizeToursRequest (message)
• OptimizeToursRequest.SearchMode (enum)
• OptimizeToursRequest.SolvingMode (enum)
• OptimizeToursResponse (message)
• OptimizeToursResponse.Metrics (message)
• OptimizeToursUriMetadata (message)
• OptimizeToursUriRequest (message)
• OptimizeToursUriResponse (message)
• OptimizeToursValidationError (message)
• OptimizeToursValidationError.FieldReference (message)
• OutputConfig (message)
• RouteModifiers (message)
• Shipment (message)
• Shipment.Load (message)
• Shipment.VisitRequest (message)
• ShipmentModel (message)
• ShipmentModel.DurationDistanceMatrix (message)
• ShipmentModel.DurationDistanceMatrix.Row (message)
• ShipmentModel.Objective (message)
• ShipmentModel.Objective.Type (enum)
• ShipmentModel.PrecedenceRule (message)
• ShipmentRoute (message)
• ShipmentRoute.Break (message)
• ShipmentRoute.EncodedPolyline (message)
• ShipmentRoute.Transition (message)
• ShipmentRoute.VehicleLoad (message)
• ShipmentRoute.Visit (message)
• ShipmentRoute.Visit.VisitType (enum)
• ShipmentTypeIncompatibility (message)
• ShipmentTypeIncompatibility.IncompatibilityMode (enum)
• ShipmentTypeRequirement (message)
• ShipmentTypeRequirement.RequirementMode (enum)
• SkippedShipment (message)
• SkippedShipment.Reason (message)
• SkippedShipment.Reason.Code (enum)
• TimeWindow (message)
• TransitionAttributes (message)
• Uri (message)
• Vehicle (message)
• Vehicle.DurationLimit (message)
• Vehicle.LoadLimit (message)
• Vehicle.LoadLimit.Interval (message)
• Vehicle.LoadLimit.LoadCost (message)
• Vehicle.TravelMode (enum)
• Vehicle.UnloadingPolicy (enum)
• VehicleFullness (message)
• Waypoint (message)

RouteOptimization

Service permettant d'optimiser les tournées de véhicules.

Validité de certains types de champs :

• google.protobuf.Timestamp
  • Les heures sont exprimées en heure Unix : secondes écoulées depuis le 1970-01-01T00:00:00+00:00.
  • "seconds" doit être compris entre [0, 253402300799], c'est-à-dire entre [1970-01-01T00:00:00+00:00, 9999-12-31T23:59:59+00:00].
  • "nanos" doit être non défini ou défini sur 0.
• google.protobuf.Duration
  • "seconds" doit être compris entre [0, 253402300799], c'est-à-dire entre [1970-01-01T00:00:00+00:00, 9999-12-31T23:59:59+00:00].
  • "nanos" doit être non défini ou défini sur 0.
• google.type.LatLng
  • La latitude doit être comprise entre -90,0 et 90,0.
  • La longitude doit être comprise entre -180,0 et 180,0.
  • Au moins l'une des valeurs de latitude et de longitude doit être différente de zéro.

BatchOptimizeTours

rpc BatchOptimizeTours(BatchOptimizeToursRequest) returns (Operation) Optimise les tournées de véhicules pour un ou plusieurs messages OptimizeToursRequest par lot. Cette méthode est une opération de longue durée (LRO). Les entrées pour l'optimisation (messages OptimizeToursRequest) et les sorties (messages OptimizeToursResponse) sont lues et écrites dans Cloud Storage au format spécifié par l'utilisateur. Comme la méthode OptimizeTours, chaque OptimizeToursRequest contient un ShipmentModel et renvoie un OptimizeToursResponse contenant des champs ShipmentRoute, qui sont un ensemble d'itinéraires à effectuer par les véhicules afin de minimiser le coût global. L'utilisateur peut interroger operations.get pour vérifier l'état de l'opération de longue durée : Si le champ done de l'opération de longue durée est défini sur "false", cela signifie qu'au moins une requête est toujours en cours de traitement. D'autres requêtes ont peut-être abouti, et leurs résultats sont disponibles dans Cloud Storage. Si le champ done de l'opération de longue durée est défini sur "true", toutes les requêtes ont été traitées. Les résultats des requêtes traitées avec succès seront disponibles dans Cloud Storage. Les résultats des requêtes ayant échoué ne seront pas disponibles dans Cloud Storage. Si le champ error de l'opération de longue durée est défini, il contient l'erreur de l'une des requêtes ayant échoué. Champs d'application des autorisations Requiert le niveau d'accès OAuth suivant : https://www.googleapis.com/auth/cloud-platform Autorisations IAM Nécessite l'autorisation IAM suivante sur la ressource parent : routeoptimization.operations.create Pour en savoir plus, consultez la documentation IAM.

OptimizeTours

rpc OptimizeTours(OptimizeToursRequest) returns (OptimizeToursResponse) Envoie un OptimizeToursRequest contenant un ShipmentModel et renvoie un OptimizeToursResponse contenant des ShipmentRoute, qui sont un ensemble d'itinéraires à effectuer par des véhicules afin de minimiser le coût global. Un modèle ShipmentModel se compose principalement de Shipment à effectuer et de Vehicle pouvant être utilisés pour transporter les Shipment. Les ShipmentRoutes attribuent des Shipments aux Vehicles. Plus précisément, ils attribuent une série de Visit à chaque véhicule, où un Visit correspond à un VisitRequest, qui est un enlèvement ou une livraison pour un Shipment. L'objectif est de fournir une attribution de ShipmentRoute à Vehicle qui minimise le coût total, où le coût comporte de nombreux composants définis dans le ShipmentModel. Champs d'application des autorisations Requiert le niveau d'accès OAuth suivant : https://www.googleapis.com/auth/cloud-platform Autorisations IAM Nécessite l'autorisation IAM suivante sur la ressource parent : routeoptimization.locations.use Pour en savoir plus, consultez la documentation IAM.

OptimizeToursLongRunning

rpc OptimizeToursLongRunning(OptimizeToursRequest) returns (Operation) Il s'agit d'une variante de la méthode OptimizeTours conçue pour les optimisations avec des valeurs de délai d'expiration élevées. Elle doit être privilégiée par rapport à la méthode OptimizeTours pour les optimisations qui prennent plus de quelques minutes. L'long-running operation (LRO) renvoyée aura un nom au format <parent>/operations/<operation_id> et pourra être utilisée pour suivre la progression du calcul. Le type de champ metadata est OptimizeToursLongRunningMetadata. Le type du champ response est OptimizeToursResponse, si l'opération réussit. Champs d'application des autorisations Requiert le niveau d'accès OAuth suivant : https://www.googleapis.com/auth/cloud-platform Autorisations IAM Nécessite l'autorisation IAM suivante sur la ressource parent : routeoptimization.operations.create Pour en savoir plus, consultez la documentation IAM.

OptimizeToursUri

rpc OptimizeToursUri(OptimizeToursUriRequest) returns (Operation) Il s'agit d'une variante de la méthode OptimizeToursLongRunning conçue pour les optimisations avec des valeurs de délai d'expiration élevées et des tailles d'entrée/sortie importantes. Le client spécifie l'URI du OptimizeToursRequest stocké dans Google Cloud Storage, et le serveur écrit le OptimizeToursResponse dans un URI Google Cloud Storage spécifié par le client. Cette méthode doit être privilégiée par rapport à la méthode OptimizeTours pour les optimisations qui prennent plus de quelques minutes et les tailles d'entrée/sortie supérieures à 8 Mo, bien qu'elle puisse également être utilisée pour des optimisations plus courtes et plus petites. L'long-running operation (LRO) renvoyée aura un nom au format <parent>/operations/<operation_id> et pourra être utilisée pour suivre la progression du calcul. Le type de champ metadata est OptimizeToursUriMetadata. Le type du champ response est OptimizeToursUriResponse, si l'opération réussit. Champs d'application des autorisations Requiert le niveau d'accès OAuth suivant : https://www.googleapis.com/auth/cloud-platform Autorisations IAM Nécessite l'autorisation IAM suivante sur la ressource parent : routeoptimization.operations.create Pour en savoir plus, consultez la documentation IAM.

AggregatedMetrics

Métriques agrégées pour ShipmentRoute (resp. pour OptimizeToursResponse) sur tous les éléments Transition et/ou Visit (resp. sur tous les éléments ShipmentRoute).

Champs
performed_shipment_count	int32 Nombre d'envois effectués. Notez qu'une paire de retrait et de livraison n'est comptabilisée qu'une seule fois.
travel_duration	Duration Durée totale du trajet pour un itinéraire ou une solution.
wait_duration	Duration Durée totale d'attente pour un itinéraire ou une solution.
delay_duration	Duration Durée totale du retard pour un itinéraire ou une solution.
break_duration	Duration Durée totale des pauses pour un itinéraire ou une solution.
visit_duration	Duration Durée totale de la visite pour un itinéraire ou une solution.
total_duration	Duration La durée totale doit être égale à la somme de toutes les durées ci-dessus. Pour les routes, il correspond également à : [ShipmentRoute.vehicle_end_time][google.maps.routeoptimization.v1.ShipmentRoute.vehicle_end_time] - [ShipmentRoute.vehicle_start_time][google.maps.routeoptimization.v1.ShipmentRoute.vehicle_start_time]
travel_distance_meters	double Distance totale parcourue pour un itinéraire ou une solution.
max_loads	map<string, VehicleLoad> Charge maximale atteinte sur l'ensemble de l'itinéraire (resp. de la solution), pour chacune des quantités sur cet itinéraire (resp. cette solution), calculée comme le maximum sur tous les Transition.vehicle_loads (resp. ShipmentRoute.metrics.max_loads.
performed_mandatory_shipment_count	int32 Nombre d'envois obligatoires effectués. Expérimental : le comportement ou l'existence de ce champ peuvent changer à l'avenir.
performed_shipment_penalty_cost_sum	double Somme des Shipment.penalty_cost des envois effectués. Expérimental : le comportement ou l'existence de ce champ peuvent changer à l'avenir.

BatchOptimizeToursMetadata

Ce type ne comporte aucun champ.

Métadonnées d'opération pour les appels BatchOptimizeToursRequest.

BatchOptimizeToursRequest

Demande d'optimisation par lot des tournées en tant qu'opération asynchrone. Chaque fichier d'entrée doit contenir un OptimizeToursRequest, et chaque fichier de sortie contiendra un OptimizeToursResponse. La requête contient des informations permettant de lire/écrire et d'analyser les fichiers. Tous les fichiers d'entrée et de sortie doivent se trouver dans le même projet.

Champs
parent	string Obligatoire. Projet et emplacement cibles pour passer un appel. Format : projects/{project-id} projects/{project-id}/locations/- Les valeurs {location-id} régionales ne sont pas acceptées.
model_configs[]	AsyncModelConfig Obligatoire. Informations d'entrée/sortie pour chaque modèle d'achat, telles que les chemins d'accès aux fichiers et les formats de données.

AsyncModelConfig

Informations permettant de résoudre un modèle d'optimisation de manière asynchrone.

Champs
display_name	string Facultatif. Nom du modèle défini par l'utilisateur, qui peut être utilisé comme alias par les utilisateurs pour suivre les modèles.
input_config	InputConfig Obligatoire. Informations sur le modèle d'entrée.
output_config	OutputConfig Obligatoire. Informations sur l'emplacement de sortie souhaité.

BatchOptimizeToursResponse

Ce type ne comporte aucun champ.

Réponse à un BatchOptimizeToursRequest. Il est renvoyé dans l'opération de longue durée une fois l'opération terminée.

BreakRule

Règles permettant de générer des pauses pour un véhicule (par exemple, des pauses déjeuner). Une pause est une période continue pendant laquelle le véhicule reste inactif à sa position actuelle et ne peut effectuer aucune visite. Une interruption peut se produire :

• pendant le trajet entre deux visites (ce qui inclut le temps juste avant ou juste après une visite, mais pas au milieu d'une visite), auquel cas il prolonge le temps de trajet correspondant entre les visites ;
• ou avant le départ du véhicule (le véhicule ne peut pas démarrer au milieu d'une pause), auquel cas cela n'affecte pas l'heure de départ du véhicule.
• ou après la fin du véhicule (idem, avec l'heure de fin du véhicule).

Champs
break_requests[]	BreakRequest Séquence de pauses. Consultez le message BreakRequest.
frequency_constraints[]	FrequencyConstraint Plusieurs FrequencyConstraint peuvent s'appliquer. Elles doivent toutes être satisfaites par les BreakRequest de ce BreakRule. Consultez FrequencyConstraint.

BreakRequest

La séquence de pauses (c'est-à-dire leur nombre et leur ordre) qui s'applique à chaque véhicule doit être connue à l'avance. Les BreakRequest répétés définissent cette séquence, dans l'ordre dans lequel ils doivent se produire. Leurs périodes (earliest_start_time / latest_start_time) peuvent se chevaucher, mais elles doivent être compatibles avec la commande (ce qui est vérifié).

Champs
earliest_start_time	Timestamp Obligatoire. Limite inférieure (inclusive) du début de la pause.
latest_start_time	Timestamp Obligatoire. Limite supérieure (inclusive) du début de la pause.
min_duration	Duration Obligatoire. Durée minimale de la pause. Doit être positive.

FrequencyConstraint

Vous pouvez limiter davantage la fréquence et la durée des pauses spécifiées ci-dessus en appliquant une fréquence de pause minimale, par exemple "Il doit y avoir une pause d'au moins une heure toutes les 12 heures". En supposant que cela puisse être interprété comme "Dans n'importe quelle fenêtre de temps glissante de 12 heures, il doit y avoir au moins une pause d'au moins une heure", cet exemple se traduirait par le FrequencyConstraint suivant :

{
   min_break_duration { seconds: 3600 }         # 1 hour.
   max_inter_break_duration { seconds: 39600 }  # 11 hours (12 - 1 = 11).
}

Le moment et la durée des pauses dans la solution respecteront toutes ces contraintes, en plus des créneaux horaires et des durées minimales déjà spécifiés dans le BreakRequest.

En pratique, un FrequencyConstraint peut s'appliquer à des pauses non consécutives. Par exemple, la programmation suivante respecte l'exemple "1 h toutes les 12 h" :

  04:00 vehicle start
   .. performing travel and visits ..
  09:00 1 hour break
  10:00 end of the break
   .. performing travel and visits ..
  12:00 20-min lunch break
  12:20 end of the break
   .. performing travel and visits ..
  21:00 1 hour break
  22:00 end of the break
   .. performing travel and visits ..
  23:59 vehicle end

Champs
min_break_duration	Duration Obligatoire. Durée minimale de la pause pour cette contrainte. Non négatif. Lisez la description de FrequencyConstraint.
max_inter_break_duration	Duration Obligatoire. Durée maximale autorisée pour tout intervalle de temps de l'itinéraire qui n'inclut pas au moins partiellement une pause de duration >= min_break_duration. Doit être positive.

DataFormat

Formats de données pour les fichiers d'entrée et de sortie.

Enums
DATA_FORMAT_UNSPECIFIED	Valeur non valide : le format ne doit pas être UNSPECIFIED.
JSON	JavaScript Object Notation.
PROTO_TEXT	Format de texte des tampons de protocole. Consultez https://protobuf.dev/reference/protobuf/textformat-spec/.

DistanceLimit

Limite définissant une distance maximale pouvant être parcourue. Il peut être dur ou mou.

Si une limite souple est définie, soft_max_meters et cost_per_kilometer_above_soft_max doivent être définis et non négatifs.

Champs
max_meters	int64 Limite stricte limitant la distance à max_meters au maximum. La limite ne doit pas être négative.
soft_max_meters	int64 Une limite souple n'impose pas de limite de distance maximale, mais son non-respect entraîne un coût qui s'ajoute aux autres coûts définis dans le modèle, avec la même unité. S'il est défini, soft_max_meters doit être inférieur à max_meters et ne doit pas être négatif.
cost_per_kilometer_below_soft_max	double Coût par kilomètre encouru, augmentant jusqu'à soft_max_meters, avec la formule : min(distance_meters, soft_max_meters) / 1000.0 * cost_per_kilometer_below_soft_max. Ce coût n'est pas accepté dans route_distance_limit.
cost_per_kilometer_above_soft_max	double Coût par kilomètre encouru si la distance est supérieure à la limite de soft_max_meters. Le coût supplémentaire est de 0 si la distance est inférieure à la limite. Sinon, la formule utilisée pour calculer le coût est la suivante : (distance_meters - soft_max_meters) / 1000.0 * cost_per_kilometer_above_soft_max. Le coût ne doit pas être négatif.

GcsDestination

Emplacement Google Cloud Storage dans lequel les fichiers de sortie seront écrits.

Champs
uri	string Obligatoire. URI Google Cloud Storage.

GcsSource

Emplacement Google Cloud Storage dans lequel le fichier d'entrée est lu.

Champs
uri	string Obligatoire. URI d'un objet Google Cloud Storage au format gs://bucket/path/to/object.

InjectedSolutionConstraint

Solution injectée dans la requête, y compris des informations sur les visites qui doivent être limitées et comment elles doivent l'être.

Champs
routes[]	ShipmentRoute Routes de la solution à injecter. Certains itinéraires peuvent être omis de la solution d'origine. Les itinéraires et les envois ignorés doivent satisfaire aux hypothèses de validité de base listées pour injected_first_solution_routes.
skipped_shipments[]	SkippedShipment Envois ignorés de la solution à injecter. Certains peuvent être omis de la solution d'origine. Consultez le champ routes.
constraint_relaxations[]	ConstraintRelaxation Pour zéro ou plusieurs groupes de véhicules, spécifie quand et dans quelle mesure assouplir les contraintes. Si ce champ est vide, tous les itinéraires de véhicules non vides sont entièrement limités.

ConstraintRelaxation

Pour un groupe de véhicules, spécifie le ou les seuils auxquels les contraintes sur les visites seront assouplies et à quel niveau. Les envois listés dans le champ skipped_shipment sont ignorés, c'est-à-dire qu'ils ne peuvent pas être effectués.

Champs
relaxations[]	Relaxation Tous les assouplissements des contraintes de visite qui s'appliqueront aux visites sur les itinéraires avec des véhicules dans vehicle_indices.
vehicle_indices[]	int32 Spécifie les indices de véhicule auxquels la contrainte de visite relaxations s'applique. Si ce champ est vide, il est considéré comme la valeur par défaut et les relaxations s'appliquent à tous les véhicules qui ne sont pas spécifiés dans d'autres constraint_relaxations. Il ne peut y avoir qu'une seule valeur par défaut, c'est-à-dire qu'un seul champ d'assouplissement de contrainte peut être vide vehicle_indices. Un index de véhicule ne peut être listé qu'une seule fois, même dans plusieurs constraint_relaxations. Un index de véhicule est mappé de la même manière que ShipmentRoute.vehicle_index, si interpret_injected_solutions_using_labels est défini sur "true" (voir le commentaire fields).

Relaxation

Si relaxations est vide, l'heure de début et la séquence de toutes les visites sur routes sont entièrement limitées, et aucune nouvelle visite ne peut être insérée ou ajoutée à ces itinéraires. De plus, l'heure de début et de fin d'un véhicule dans routes est entièrement limitée, sauf si le véhicule est vide (c'est-à-dire qu'il n'a pas de visites et que used_if_route_is_empty est défini sur "false" dans le modèle).

relaxations(i).level spécifie le niveau d'assouplissement des contraintes appliqué à une visite #j qui satisfait :

• route.visits(j).start_time >= relaxations(i).threshold_time ET
• j + 1 >= relaxations(i).threshold_visit_count

De même, le démarrage du véhicule est assoupli à relaxations(i).level s'il remplit les conditions suivantes :

• vehicle_start_time >= relaxations(i).threshold_time ET
• relaxations(i).threshold_visit_count == 0 et la fin du véhicule est assouplie à relaxations(i).level si elle satisfait :
• vehicle_end_time >= relaxations(i).threshold_time ET
• route.visits_size() + 1 >= relaxations(i).threshold_visit_count

Pour appliquer un niveau d'assouplissement si une visite répond à la condition threshold_visit_count OU threshold_time, ajoutez deux relaxations avec le même level : l'un avec seulement threshold_visit_count défini et l'autre avec seulement threshold_time défini. Si une visite remplit les conditions de plusieurs relaxations, le niveau le plus souple s'applique. Par conséquent, du début du véhicule aux visites de l'itinéraire dans l'ordre jusqu'à la fin du véhicule, le niveau de relaxation devient plus détendu : c'est-à-dire que le niveau de relaxation ne diminue pas à mesure que l'itinéraire progresse.

Le moment et l'ordre des visites d'itinéraire qui ne remplissent pas les conditions de seuil d'un relaxations sont entièrement limités, et aucune visite ne peut être insérée dans ces séquences. De plus, si le début ou la fin d'un véhicule ne remplit pas les conditions d'un assouplissement, l'heure est fixe, sauf si le véhicule est vide.

Champs
level	Level Niveau d'assouplissement des contraintes qui s'applique lorsque les conditions à partir de threshold_time ET d'au moins threshold_visit_count sont remplies.
threshold_time	Timestamp Heure à laquelle ou après laquelle l'assouplissement level peut être appliqué.
threshold_visit_count	int32 Nombre de visites à partir duquel l'assouplissement level peut être appliqué. Si threshold_visit_count est défini sur 0 (ou n'est pas défini), level peut être appliqué directement au démarrage du véhicule. Si la valeur est route.visits_size() + 1, le level ne peut être appliqué qu'à l'extrémité du véhicule. Si elle est supérieure à route.visits_size() + 1, level n'est pas appliqué du tout pour cette route.

Niveau

Exprime les différents niveaux d'assouplissement des contraintes, qui sont appliqués pour une visite et celles qui suivent lorsqu'elle remplit les conditions de seuil.

L'énumération ci-dessous est classée par ordre d'assouplissement croissant.

Enums
LEVEL_UNSPECIFIED	Niveau d'assouplissement implicite par défaut : aucune contrainte n'est assouplie, c'est-à-dire que toutes les visites sont entièrement contraintes. Cette valeur ne doit pas être explicitement utilisée dans level.
RELAX_VISIT_TIMES_AFTER_THRESHOLD	Les heures de début des visites et les heures de début/fin des véhicules seront assouplies, mais chaque visite reste liée au même véhicule et l'ordre des visites doit être respecté : aucune visite ne peut être insérée entre elles ou avant elles.
RELAX_VISIT_TIMES_AND_SEQUENCE_AFTER_THRESHOLD	Identique à RELAX_VISIT_TIMES_AFTER_THRESHOLD, mais la séquence de visites est également assouplie : les visites ne peuvent être effectuées que par ce véhicule, mais peuvent potentiellement ne pas être effectuées.
RELAX_ALL_AFTER_THRESHOLD	Identique à RELAX_VISIT_TIMES_AND_SEQUENCE_AFTER_THRESHOLD, mais le véhicule est également assoupli : les visites sont totalement sans frais à l'heure seuil ou après, et peuvent potentiellement ne pas être effectuées.

InputConfig

Spécifiez une entrée pour [BatchOptimizeTours][google.maps.routeoptimization.v1.RouteOptimizationService.BatchOptimizeTours].

Champs
data_format	DataFormat Obligatoire. Format des données d'entrée.
Champ d'union source. Obligatoire. source ne peut être qu'un des éléments suivants :
gcs_source	GcsSource Un emplacement Google Cloud Storage. Il doit s'agir d'un seul objet (fichier).

Emplacement

Encapsule un emplacement (un point géographique et un cap facultatif).

Champs
lat_lng	LatLng Coordonnées géographiques du point de cheminement.
heading	int32 Orientation de la boussole associée au sens de circulation. Cette valeur permet de spécifier le côté de la route à utiliser pour la prise en charge et la dépose. Les valeurs de cap peuvent être comprises entre 0 et 360, où 0 correspond au nord, 90 à l'est, etc.

OptimizeToursLongRunningMetadata

Ce type ne comporte aucun champ.

Métadonnées d'opération pour les appels OptimizeToursLongRunning.

OptimizeToursRequest

Requête à envoyer à un résolveur d'optimisation de tournées qui définit le modèle d'expédition à résoudre ainsi que les paramètres d'optimisation.

Champs
parent	string Obligatoire. Projet ou emplacement cibles pour passer un appel. Format : projects/{project-id} projects/{project-id}/locations/- Les valeurs {location-id} régionales ne sont pas acceptées.
timeout	Duration Si ce délai avant expiration est défini, le serveur renvoie une réponse avant que le délai avant expiration ne soit écoulé ou que le délai avant expiration du serveur pour les requêtes synchrones ne soit atteint, selon la première occurrence. Pour les requêtes asynchrones, le serveur génère une solution (si possible) avant l'expiration du délai.
model	ShipmentModel Modèle d'envoi à résoudre.
solving_mode	SolvingMode Par défaut, le mode de résolution est DEFAULT_SOLVE (0).
search_mode	SearchMode Mode de recherche utilisé pour résoudre la requête.
injected_first_solution_routes[]	ShipmentRoute Guider l'algorithme d'optimisation pour trouver une première solution semblable à une solution précédente. Le modèle est contraint lorsque la première solution est créée. Tous les envois non effectués sur un itinéraire sont implicitement ignorés dans la première solution, mais ils peuvent être effectués dans les solutions successives. La solution doit satisfaire à certaines hypothèses de validité de base : Pour toutes les routes, vehicle_index doit être compris dans la plage et ne pas être dupliqué. Pour toutes les visites, shipment_index et visit_request_index doivent être compris dans la plage. un envoi ne peut être référencé que sur un seul itinéraire. L'enlèvement d'un envoi de type enlèvement-livraison doit être effectué avant la livraison. Une seule alternative de retrait ou de livraison d'un envoi peut être effectuée. pour toutes les routes, les temps augmentent (c'est-à-dire que vehicle_start_time <= visits[0].start_time <= visits[1].start_time ... <= vehicle_end_time). un envoi ne peut être effectué que sur un véhicule autorisé. Un véhicule est autorisé si Shipment.allowed_vehicle_indices est vide ou si son vehicle_index est inclus dans Shipment.allowed_vehicle_indices. Si la solution injectée n'est pas réalisable, une erreur de validation n'est pas nécessairement renvoyée. Une erreur indiquant l'impossibilité peut être renvoyée à la place.
injected_solution_constraint	InjectedSolutionConstraint Limitez l'algorithme d'optimisation pour trouver une solution finale semblable à une solution précédente. Par exemple, cela peut être utilisé pour figer des parties d'itinéraires qui ont déjà été parcourues ou qui doivent l'être, mais qui ne doivent pas être modifiées. Si la solution injectée n'est pas réalisable, une erreur de validation n'est pas nécessairement renvoyée. Une erreur indiquant l'impossibilité peut être renvoyée à la place.
refresh_details_routes[]	ShipmentRoute Si ce champ n'est pas vide, les itinéraires indiqués seront actualisés, sans modifier la séquence de visites ou les temps de trajet sous-jacents : seuls les autres détails seront mis à jour. Cela ne résout pas le modèle. Depuis novembre 2020, cela ne renseigne que les polylignes des itinéraires non vides et nécessite que populate_polylines soit défini sur "true". Les champs route_polyline des itinéraires transmis peuvent ne pas être cohérents avec l'itinéraire transitions. Ce champ ne doit pas être utilisé avec injected_first_solution_routes ou injected_solution_constraint. Shipment.ignore et Vehicle.ignore n'ont aucune incidence sur le comportement. Les polylignes sont toujours renseignées entre toutes les visites de tous les itinéraires non vides, que les envois ou les véhicules associés soient ignorés ou non.
interpret_injected_solutions_using_labels	bool Si la réponse est "oui" : utilise ShipmentRoute.vehicle_label au lieu de vehicle_index pour faire correspondre les itinéraires d'une solution injectée avec les véhicules de la requête ; réutilise le mappage de l'ShipmentRoute.vehicle_index d'origine vers le nouvel ShipmentRoute.vehicle_index pour mettre à jour ConstraintRelaxation.vehicle_indices s'il n'est pas vide, mais le mappage doit être sans ambiguïté (c'est-à-dire que plusieurs ShipmentRoute ne doivent pas partager le même vehicle_index d'origine). utilise ShipmentRoute.Visit.shipment_label au lieu de shipment_index pour faire correspondre les visites d'une solution injectée avec les envois de la requête ; utilise SkippedShipment.label au lieu de SkippedShipment.index pour faire correspondre les envois ignorés dans la solution injectée avec les envois de la requête. Cette interprétation s'applique aux champs injected_first_solution_routes, injected_solution_constraint et refresh_details_routes. Elle peut être utilisée lorsque les indices d'envoi ou de véhicule de la requête ont changé depuis la création de la solution, par exemple parce que des envois ou des véhicules ont été supprimés de la requête ou ajoutés à celle-ci. Si la valeur est "true", les libellés des catégories suivantes ne doivent pas apparaître plus d'une fois dans leur catégorie : Vehicle.label dans la requête ; Shipment.label dans la requête ; ShipmentRoute.vehicle_label dans la solution injectée ; SkippedShipment.label et ShipmentRoute.Visit.shipment_label dans la solution injectée (à l'exception des paires de visites d'enlèvement/livraison, dont le shipment_label doit apparaître deux fois). Si un vehicle_label de la solution injectée ne correspond pas à un véhicule de la requête, l'itinéraire correspondant est supprimé de la solution, ainsi que ses visites. Si un shipment_label de la solution injectée ne correspond pas à un envoi de la requête, la visite correspondante est supprimée de la solution. Si un SkippedShipment.label de la solution injectée ne correspond pas à un envoi de la requête, il SkippedShipment est supprimé de la solution. La suppression de visites d'itinéraires ou d'itinéraires entiers d'une solution injectée peut avoir un effet sur les contraintes implicites, ce qui peut entraîner une modification de la solution, des erreurs de validation ou une impossibilité de résolution. REMARQUE : L'appelant doit s'assurer que chaque Vehicle.label (resp. Shipment.label) identifie de manière unique une entité de véhicule (resp. d'envoi) utilisée dans les deux requêtes pertinentes : la requête passée qui a produit le OptimizeToursResponse utilisé dans la solution injectée et la requête actuelle qui inclut la solution injectée. Les vérifications d'unicité décrites ci-dessus ne suffisent pas à garantir cette exigence.
consider_road_traffic	bool Prenez en compte l'estimation du trafic pour calculer les champs ShipmentRoute Transition.travel_duration, Visit.start_time et vehicle_end_time, pour définir le champ ShipmentRoute.has_traffic_infeasibilities et pour calculer le champ OptimizeToursResponse.total_cost.
populate_polylines	bool Si la valeur est "true", les polylignes seront renseignées dans les ShipmentRoute de réponse.
populate_transition_polylines	bool Si la valeur est "true", les polylignes et les jetons de route seront renseignés dans la réponse ShipmentRoute.transitions.
allow_large_deadline_despite_interruption_risk	bool Si ce champ est défini, la requête peut avoir un délai avant expiration (voir https://grpc.io/blog/deadlines) de 60 minutes maximum. Sinon, le délai maximal n'est que de 30 minutes. Notez que les requêtes de longue durée présentent un risque d'interruption nettement plus élevé (mais toujours faible).
use_geodesic_distances	bool Si la valeur est "true", les distances de trajet seront calculées à l'aide des distances géodésiques au lieu des distances Google Maps, et les temps de trajet seront calculés à l'aide des distances géodésiques avec une vitesse définie par geodesic_meters_per_second.
label	string Libellé pouvant être utilisé pour identifier cette requête, renvoyé dans le OptimizeToursResponse.request_label.
geodesic_meters_per_second	double Lorsque use_geodesic_distances est défini sur "true", ce champ doit être défini et définit la vitesse appliquée pour calculer les temps de trajet. Sa valeur doit être d'au moins 1,0 mètre/seconde.
max_validation_errors	int32 Tronque le nombre d'erreurs de validation renvoyées. Ces erreurs sont généralement associées à une charge utile d'erreur INVALID_ARGUMENT en tant que détail d'erreur BadRequest (https://cloud.google.com/apis/design/errors#error_details), sauf si solving_mode=VALIDATE_ONLY : consultez le champ OptimizeToursResponse.validation_errors. La valeur par défaut est de 100,et la limite est de 10 000.

SearchMode

Mode définissant le comportement de la recherche, en arbitrant entre la latence et la qualité de la solution. Dans tous les modes, le délai avant expiration global de la requête est appliqué.

Enums
SEARCH_MODE_UNSPECIFIED	Mode de recherche non spécifié, équivalent à RETURN_FAST.
RETURN_FAST	Arrêtez la recherche après avoir trouvé la première bonne solution.
CONSUME_ALL_AVAILABLE_TIME	Consacrez tout le temps disponible à la recherche de meilleures solutions.

SolvingMode

Définit la manière dont le résolveur doit gérer la requête. Dans tous les modes sauf VALIDATE_ONLY, si la requête n'est pas valide, vous recevrez une erreur INVALID_REQUEST. Consultez max_validation_errors pour limiter le nombre d'erreurs renvoyées.

Enums
DEFAULT_SOLVE	Résoudre le modèle. Des avertissements peuvent être émis dans [OptimizeToursResponse.validation_errors][google.cloud.optimization.v1.OptimizeToursResponse.validation_errors].
VALIDATE_ONLY	Valide uniquement le modèle sans le résoudre : renseigne autant de OptimizeToursResponse.validation_errors que possible.
DETECT_SOME_INFEASIBLE_SHIPMENTS	Ne renseigne que OptimizeToursResponse.validation_errors ou OptimizeToursResponse.skipped_shipments, et ne résout pas le reste de la requête (status et routes ne sont pas définis dans la réponse). Si des impossibilités sont détectées dans les itinéraires injected_solution_constraint, elles sont renseignées dans le champ OptimizeToursResponse.validation_errors et OptimizeToursResponse.skipped_shipments est laissé vide. IMPORTANT : Tous les envois infaisables ne sont pas renvoyés ici, mais uniquement ceux qui sont détectés comme infaisables lors du prétraitement.
TRANSFORM_AND_RETURN_REQUEST	Ce mode ne fonctionne que si ShipmentModel.objectives n'est pas vide. La demande n'est pas résolue. Il est uniquement validé et rempli avec les coûts correspondant aux objectifs donnés. Consultez également la documentation de ShipmentModel.objectives. La requête obtenue est renvoyée sous la forme OptimizeToursResponse.processed_request. Expérimental : pour en savoir plus, consultez https://developers.google.com/maps/tt/route-optimization/experimental/objectives/make-request.

OptimizeToursResponse

Réponse après la résolution d'un problème d'optimisation de tournée contenant les itinéraires suivis par chaque véhicule, les envois qui ont été ignorés et le coût global de la solution.

Champs
routes[]	ShipmentRoute Itinéraires calculés pour chaque véhicule. Le i-ème itinéraire correspond au i-ème véhicule du modèle.
request_label	string Copie de OptimizeToursRequest.label, si un libellé a été spécifié dans la requête.
skipped_shipments[]	SkippedShipment Liste de tous les envois ignorés.
validation_errors[]	OptimizeToursValidationError Liste de toutes les erreurs de validation que nous avons pu détecter indépendamment. Consultez l'explication "ERREURS MULTIPLES" pour le message OptimizeToursValidationError. Au lieu d'erreurs, cela inclura des avertissements si solving_mode est défini sur DEFAULT_SOLVE.
processed_request	OptimizeToursRequest Dans certains cas, nous modifions la requête entrante avant de la résoudre, par exemple en ajoutant des coûts. Si solving_mode == TRANSFORM_AND_RETURN_REQUEST, la requête modifiée est renvoyée ici. Expérimental : pour en savoir plus, consultez https://developers.google.com/maps/tt/route-optimization/experimental/objectives/make-request.
metrics	Metrics Métriques de durée, de distance et d'utilisation pour cette solution.

Métriques

Métriques globales, agrégées sur toutes les routes.

Champs
aggregated_route_metrics	AggregatedMetrics Agrégé sur les routes. Chaque métrique est la somme (ou la valeur maximale, pour les charges) de tous les champs ShipmentRoute.metrics portant le même nom.
skipped_mandatory_shipment_count	int32 Nombre d'envois obligatoires ignorés.
used_vehicle_count	int32 Nombre de véhicules utilisés. Remarque : Si un itinéraire de véhicule est vide et que Vehicle.used_if_route_is_empty est défini sur "true", le véhicule est considéré comme utilisé.
earliest_vehicle_start_time	Timestamp Heure de début la plus précoce pour un véhicule utilisé, calculée comme le minimum sur tous les véhicules utilisés de ShipmentRoute.vehicle_start_time.
latest_vehicle_end_time	Timestamp Heure de fin la plus tardive pour un véhicule utilisé, calculée comme le maximum de ShipmentRoute.vehicle_end_time sur tous les véhicules utilisés.
costs	map<string, double> Coût de la solution, réparti par champs de requête liés aux coûts. Les clés sont des chemins d'accès proto, relatifs à la requête OptimizeToursRequest d'entrée, par exemple "model.shipments.pickups.cost", et les valeurs sont le coût total généré par le champ de coût correspondant, agrégé sur l'ensemble de la solution. En d'autres termes, costs["model.shipments.pickups.cost"] est la somme de tous les coûts de retrait de la solution. Tous les coûts définis dans le modèle sont indiqués en détail ici, à l'exception de ceux liés aux TransitionAttributes, qui ne sont indiqués que de manière agrégée à partir de janvier 2022.
total_cost	double Coût total de la solution. Somme de toutes les valeurs de la carte des coûts.

OptimizeToursUriMetadata

Ce type ne comporte aucun champ.

Métadonnées d'opération pour les appels OptimizeToursUri.

OptimizeToursUriRequest

Requête utilisée par la méthode OptimizeToursUri.

Champs
parent	string Obligatoire. Projet ou emplacement cibles pour passer un appel. Format : projects/{project-id} projects/{project-id}/locations/- Les valeurs {location-id} régionales ne sont pas acceptées.
input	Uri Obligatoire. URI de l'objet Cloud Storage contenant le OptimizeToursRequest.
output	Uri Obligatoire. URI de l'objet Cloud Storage qui contiendra le OptimizeToursResponse.

OptimizeToursUriResponse

Réponse renvoyée par la méthode OptimizeToursUri.

Champs

output

Uri Facultatif. URI de l'objet Cloud Storage contenant le OptimizeToursResponse encodé au format JSON ou textproto. Si l'objet a été encodé au format JSON, l'extension du nom de l'objet sera .json. Si l'objet a été encodé au format textproto, l'extension du nom de l'objet sera .txtpb. Le crc32_checksum de la ressource peut être utilisé pour vérifier que le contenu de la ressource n'a pas été modifié.

OptimizeToursValidationError

Décrit une erreur ou un avertissement rencontré lors de la validation d'un OptimizeToursRequest.

Champs
code	int32 Une erreur de validation est définie par la paire (code, display_name), qui est toujours présente. Les champs qui suivent cette section fournissent plus de contexte sur l'erreur. ERREURS MULTIPLES : lorsque plusieurs erreurs se produisent, le processus de validation tente d'en afficher plusieurs. Comme pour un compilateur, ce processus n'est pas parfait. Certaines erreurs de validation sont "fatales", ce qui signifie qu'elles interrompent l'ensemble du processus de validation. C'est le cas, entre autres, des erreurs display_name="UNSPECIFIED". Certaines erreurs peuvent entraîner l'omission d'autres erreurs lors du processus de validation. STABILITÉ : code et display_name doivent être très stables. Toutefois, de nouveaux codes et noms à afficher peuvent apparaître au fil du temps. Une requête (non valide) donnée peut donc générer une paire (code, display_name) différente, car la nouvelle erreur a masqué l'ancienne. Par exemple, consultez "MULTIPLE ERRORS".
display_name	string Nom à afficher de l'erreur.
fields[]	FieldReference Un contexte d'erreur peut impliquer 0, 1 (la plupart du temps) ou plusieurs champs. Par exemple, pour faire référence au véhicule 4 et au premier enlèvement de l'envoi 2, procédez comme suit : fields { name: "vehicles" index: 4} fields { name: "shipments" index: 2 sub_field {name: "pickups" index: 0} } Notez toutefois que la cardinalité de fields ne doit pas changer pour un code d'erreur donné.
error_message	string Chaîne lisible par l'humain décrivant l'erreur. Il existe un mappage 1:1 entre code et error_message (lorsque code != "UNSPECIFIED"). STABILITÉ : non stable. Le message d'erreur associé à un code donné peut changer (pour plus de clarté) au fil du temps. Veuillez plutôt vous fier aux display_name et code.
offending_values	string Peut contenir la ou les valeurs du ou des champs. Cette option n'est pas toujours disponible. Vous ne devez absolument pas vous y fier et ne l'utiliser que pour le débogage manuel du modèle.

FieldReference

Spécifie un contexte pour l'erreur de validation. Un FieldReference fait toujours référence à un champ donné de ce fichier et suit la même structure hiérarchique. Par exemple, nous pouvons spécifier l'élément 2 de start_time_windows du véhicule 5 à l'aide de :

name: "vehicles" index: 5 sub_field { name: "end_time_windows" index: 2 }

Toutefois, nous omettons les entités de premier niveau telles que OptimizeToursRequest ou ShipmentModel pour éviter de surcharger le message.

Champs
name	string Nom du champ (par exemple, "vehicles").
sub_field	FieldReference Sous-champ imbriqué de manière récursive, si nécessaire.
Champ d'union index_or_key. index_or_key ne peut être qu'un des éléments suivants :
index	int32 Index du champ s'il est répété.
key	string Clé si le champ est une carte.

OutputConfig

Spécifiez une destination pour les résultats de [BatchOptimizeTours][google.maps.routeoptimization.v1.RouteOptimizationService.BatchOptimizeTours].

Champs
data_format	DataFormat Obligatoire. Format des données de sortie.
Champ d'union destination. Obligatoire. destination ne peut être qu'un des éléments suivants :
gcs_destination	GcsDestination Emplacement Google Cloud Storage dans lequel écrire la sortie.

RouteModifiers

Encapsule un ensemble de conditions facultatives à remplir lors du calcul des itinéraires des véhicules. Cette option est semblable à RouteModifiers dans l'API Routes Preferred de Google Maps Platform. Consultez https://developers.google.com/maps/documentation/routes/reference/rest/v2/RouteModifiers.

Champs
avoid_tolls	bool Indique s'il faut éviter les routes à péage dans la mesure du possible. La priorité sera donnée aux itinéraires sans routes à péage. S'applique uniquement aux modes de transport motorisés.
avoid_highways	bool Indique s'il faut éviter les autoroutes dans la mesure du possible. La priorité sera donnée aux itinéraires ne contenant pas d'autoroutes. S'applique uniquement aux modes de transport motorisés.
avoid_ferries	bool Indique s'il faut éviter les ferries dans la mesure du possible. La priorité sera donnée aux itinéraires n'incluant pas de trajets en ferry. S'applique uniquement aux modes de transport motorisés.
avoid_indoor	bool Facultatif. Indique s'il faut éviter de naviguer en intérieur lorsque cela est possible. La priorité sera donnée aux itinéraires ne contenant pas de navigation en intérieur. S'applique uniquement au mode de transport WALKING.

Livraison

L'expédition d'un seul article, d'un de ses points de retrait à l'un de ses points de livraison. Pour qu'un envoi soit considéré comme effectué, un véhicule unique doit se rendre à l'un de ses lieux de retrait (et réduire ses capacités de réserve en conséquence), puis à l'un de ses lieux de livraison (et donc augmenter à nouveau ses capacités de réserve en conséquence).

Champs
display_name	string Nom à afficher de l'envoi défini par l'utilisateur. Il peut comporter jusqu'à 63 caractères et utiliser des caractères UTF-8.
pickups[]	VisitRequest Ensemble d'alternatives de retrait associées à l'envoi. Si ce paramètre n'est pas spécifié, le véhicule n'a besoin de se rendre qu'à un emplacement correspondant aux livraisons.
deliveries[]	VisitRequest Ensemble d'alternatives de livraison associées à l'envoi. Si ce paramètre n'est pas spécifié, le véhicule n'a besoin de se rendre qu'à un emplacement correspondant aux prises en charge.
load_demands	map<string, Load> Exigences de chargement de l'envoi (par exemple, poids, volume, nombre de palettes, etc.) Les clés de la carte doivent être des identifiants décrivant le type de charge correspondante, idéalement en incluant également les unités. Par exemple : "weight_kg", "volume_gallons", "pallet_count", etc. Si une clé donnée n'apparaît pas dans la carte, la charge correspondante est considérée comme nulle.
allowed_vehicle_indices[]	int32 Ensemble de véhicules pouvant effectuer cette livraison. Si ce champ est vide, tous les véhicules peuvent l'effectuer. Les véhicules sont indiqués par leur index dans la liste vehicles de ShipmentModel.
costs_per_vehicle[]	double Spécifie le coût encouru lorsque cet envoi est livré par chaque véhicule. Si ce paramètre est spécifié, il doit comporter : le même nombre d'éléments que costs_per_vehicle_indices. costs_per_vehicle[i] correspond au véhicule costs_per_vehicle_indices[i] du modèle. le même nombre d'éléments que de véhicules dans le modèle. Le i-ème élément correspond au véhicule n° i du modèle. Ces coûts doivent être exprimés dans la même unité que penalty_cost et ne doivent pas être négatifs. Laissez ce champ vide s'il n'y a pas de frais de ce type.
costs_per_vehicle_indices[]	int32 Indices des véhicules auxquels costs_per_vehicle s'applique. S'il n'est pas vide, il doit comporter le même nombre d'éléments que costs_per_vehicle. Un index de véhicule ne peut pas être spécifié plus d'une fois. Si un véhicule est exclu de costs_per_vehicle_indices, son coût est de zéro.
pickup_to_delivery_absolute_detour_limit	Duration Spécifie la durée maximale absolue du détour par rapport au trajet le plus court entre le point de retrait et le point de livraison. Si elle est spécifiée, elle doit être non négative, et l'envoi doit contenir au moins un enlèvement et une livraison. Par exemple, soit t le temps le plus court pour aller de l'alternative d'enlèvement sélectionnée directement à l'alternative de livraison sélectionnée. Ensuite, la définition de pickup_to_delivery_absolute_detour_limit applique : start_time(delivery) - start_time(pickup) <= t + pickup_to_delivery_absolute_detour_limit Si des limites relatives et absolues sont spécifiées pour un même envoi, la limite la plus contraignante est utilisée pour chaque paire enlèvement/livraison possible. Depuis octobre 2017, les détours ne sont acceptés que lorsque les durées de trajet ne dépendent pas des véhicules.
pickup_to_delivery_time_limit	Duration Spécifie la durée maximale entre le début de l'enlèvement et le début de la livraison d'un envoi. Si elle est spécifiée, elle doit être non négative, et l'envoi doit contenir au moins un enlèvement et une livraison. Cela ne dépend pas des alternatives sélectionnées pour l'enlèvement et la livraison, ni de la vitesse du véhicule. Vous pouvez spécifier cette option en même temps que les contraintes de détour maximal : la solution respectera les deux spécifications.
shipment_type	string Chaîne non vide spécifiant un "type" pour cet envoi. Cette fonctionnalité permet de définir des incompatibilités ou des exigences entre les shipment_types (voir shipment_type_incompatibilities et shipment_type_requirements dans ShipmentModel). Diffère de visit_types, qui est spécifié pour une seule visite : tous les enlèvements/livraisons appartenant au même envoi partagent le même shipment_type.
label	string Spécifie un libellé pour cet envoi. Cette étiquette est indiquée dans la réponse dans le champ shipment_label de l'élément ShipmentRoute.Visit correspondant.
ignore	bool Si la valeur est "true", ignorez cet envoi, mais n'appliquez pas de penalty_cost. Ignorer un envoi entraîne une erreur de validation lorsqu'il y a des shipment_type_requirements dans le modèle. Il est possible d'ignorer un envoi effectué dans injected_first_solution_routes ou injected_solution_constraint. Le résolveur supprime les visites de retrait/livraison associées de l'itinéraire d'exécution. Les precedence_rules qui font référence à des envois ignorés seront également ignorés.
penalty_cost	double Si l'envoi n'est pas effectué, cette pénalité est ajoutée au coût global des itinéraires. Un envoi est considéré comme terminé si l'une de ses alternatives d'enlèvement et de livraison est visitée. Le coût peut être exprimé dans la même unité que celle utilisée pour tous les autres champs liés aux coûts dans le modèle, et doit être positif. IMPORTANT : Si cette pénalité n'est pas spécifiée, elle est considérée comme infinie, c'est-à-dire que l'envoi doit être effectué.
pickup_to_delivery_relative_detour_limit	double Spécifie la durée maximale du détour relatif par rapport au trajet le plus court entre le point de retrait et le point de livraison. Si elle est spécifiée, elle doit être non négative, et l'envoi doit contenir au moins un enlèvement et une livraison. Par exemple, soit t le temps le plus court pour aller de l'alternative de retrait sélectionnée directement à l'alternative de livraison sélectionnée. Ensuite, la définition de pickup_to_delivery_relative_detour_limit applique : start_time(delivery) - start_time(pickup) <= std::ceil(t * (1.0 + pickup_to_delivery_relative_detour_limit)) Si des limites relatives et absolues sont spécifiées pour un même envoi, la limite la plus contraignante est utilisée pour chaque paire de retrait/livraison possible. Depuis octobre 2017, les détours ne sont acceptés que lorsque les durées de trajet ne dépendent pas des véhicules.

Charger

Lors d'une visite, une quantité prédéfinie peut être ajoutée à la charge du véhicule s'il s'agit d'un retrait, ou soustraite s'il s'agit d'une livraison. Ce message définit ce montant. Consultez les load_demands.

Champs
amount	int64 Montant de la variation de la charge du véhicule effectuant la visite correspondante. Comme il s'agit d'un entier, il est conseillé aux utilisateurs de choisir une unité appropriée pour éviter toute perte de précision. Doit être ≥ 0.

VisitRequest

Demande de visite pouvant être effectuée par un véhicule : elle comporte une géolocalisation (ou deux, voir ci-dessous), des heures d'ouverture et de fermeture représentées par des périodes, et une durée de service (temps passé par le véhicule une fois arrivé pour récupérer ou déposer des marchandises).

Champs
arrival_location	LatLng Emplacement géographique où le véhicule arrive lorsqu'il effectue cette VisitRequest. Si le modèle d'envoi comporte des matrices de distance de durée, arrival_location ne doit pas être spécifié.
arrival_waypoint	Waypoint Point de cheminement où le véhicule arrive lorsqu'il effectue cette VisitRequest. Si le modèle d'envoi comporte des matrices de distance de durée, arrival_waypoint ne doit pas être spécifié.
departure_location	LatLng Emplacement géographique d'où part le véhicule après avoir terminé cette VisitRequest. Peut être omis s'il est identique à arrival_location. Si le modèle d'envoi comporte des matrices de distance de durée, departure_location ne doit pas être spécifié.
departure_waypoint	Waypoint Point de cheminement d'où le véhicule part après avoir terminé cette VisitRequest. Peut être omis s'il est identique à arrival_waypoint. Si le modèle d'envoi comporte des matrices de distance de durée, departure_waypoint ne doit pas être spécifié.
tags[]	string Spécifie les tags associés à la demande de visite. Les chaînes vides ou en double ne sont pas autorisées.
time_windows[]	TimeWindow Plages horaires qui limitent l'heure d'arrivée à une visite. Notez qu'un véhicule peut partir en dehors de la fenêtre d'heure d'arrivée, c'est-à-dire que l'heure d'arrivée et la durée n'ont pas besoin de se trouver dans une fenêtre de temps. Cela peut entraîner un temps d'attente si le véhicule arrive avant TimeWindow.start_time. L'absence de TimeWindow signifie que le véhicule peut effectuer cette visite à tout moment. Les intervalles de temps doivent être disjoints, c'est-à-dire qu'aucun intervalle de temps ne doit chevaucher un autre ou être adjacent à un autre, et ils doivent être classés par ordre croissant. cost_per_hour_after_soft_end_time et soft_end_time ne peuvent être définis que s'il n'y a qu'une seule période.
duration	Duration Durée de la visite, c'est-à-dire le temps passé par le véhicule entre l'arrivée et le départ (à ajouter au temps d'attente possible ; voir time_windows).
cost	double Coût de la prise en charge de cette demande de visite sur un itinéraire de véhicule. Vous pouvez l'utiliser pour payer des frais différents pour chaque option de retrait ou de livraison d'un colis. Ce coût doit être exprimé dans la même unité que Shipment.penalty_cost et ne doit pas être négatif.
load_demands	map<string, Load> Demandes de chargement de cette demande de visite. Ce champ est identique au champ Shipment.load_demands, mais il ne s'applique qu'à ce VisitRequest au lieu de l'ensemble de l'Shipment. Les demandes listées ici sont ajoutées à celles listées dans Shipment.load_demands.
visit_types[]	string Spécifie les types de visite. Cela peut être utilisé pour allouer le temps supplémentaire nécessaire à un véhicule pour effectuer cette visite (voir Vehicle.extra_visit_duration_for_visit_type). Un type ne peut apparaître qu'une seule fois.
label	string Spécifie un libellé pour ce VisitRequest. Cette étiquette est signalée dans la réponse en tant que visit_label dans le ShipmentRoute.Visit correspondant.
avoid_u_turns	bool Indique si les demi-tours doivent être évités sur les itinéraires en voiture à cet emplacement. L'évitement des demi-tours est effectué dans la mesure du possible, et l'évitement complet n'est pas garanti. Il s'agit d'une fonctionnalité expérimentale dont le comportement est susceptible de changer. Expérimental : pour en savoir plus, consultez https://developers.google.com/maps/tt/route-optimization/experimental/u-turn-avoidance/make-request.

ShipmentModel

Un modèle d'envoi contient un ensemble d'envois qui doivent être effectués par un ensemble de véhicules, tout en minimisant le coût global, qui est la somme des éléments suivants :

• le coût de l'itinéraire des véhicules (somme du coût par durée totale, du coût par temps de trajet et du coût fixe pour tous les véhicules).
• les pénalités pour livraison non effectuée.
• le coût de la durée globale des expéditions

Champs
shipments[]	Shipment Ensemble d'envois à effectuer dans le modèle.
vehicles[]	Vehicle Ensemble de véhicules pouvant être utilisés pour effectuer des visites.
objectives[]	Objective Ensemble d'objectifs pour ce modèle, que nous transformerons en coûts. S'il n'est pas vide, le modèle d'entrée doit être sans coût. Pour obtenir la requête modifiée, veuillez utiliser solving_mode = TRANSFORM_AND_RETURN_REQUEST. Notez que la demande ne sera pas résolue dans ce cas. Consultez la documentation correspondante. Expérimental : pour en savoir plus, consultez https://developers.google.com/maps/tt/route-optimization/experimental/objectives/make-request.
global_start_time	Timestamp Heures de début et de fin globales du modèle : aucune heure en dehors de cette plage ne peut être considérée comme valide. La période du modèle doit être inférieure à un an, c'est-à-dire que l'intervalle entre global_end_time et global_start_time doit être inférieur à 31 536 000 secondes. Lorsque vous utilisez des champs cost_per_*hour, vous pouvez définir un intervalle plus court pour cette période afin d'améliorer les performances (par exemple, si vous modélisez un seul jour, vous devez définir les limites de temps globales sur ce jour). Si ce champ n'est pas défini, la valeur par défaut est le 1er janvier 1970 à 00:00:00 UTC (c'est-à-dire secondes : 0, nanos : 0).
global_end_time	Timestamp Si ce champ n'est pas défini, la valeur par défaut est le 1er janvier 1971 à 00:00:00 UTC (soit 31536000 secondes, 0 nanoseconde).
global_duration_cost_per_hour	double La "durée globale" du plan global correspond à la différence entre l'heure de début effective la plus précoce et l'heure de fin effective la plus tardive de tous les véhicules. Les utilisateurs peuvent attribuer un coût par heure à cette quantité pour essayer d'optimiser l'exécution des jobs le plus tôt possible, par exemple. Ce coût doit être exprimé dans la même unité que Shipment.penalty_cost.
duration_distance_matrices[]	DurationDistanceMatrix Spécifie les matrices de durée et de distance utilisées dans le modèle. Si ce champ est vide, Google Maps ou les distances géodésiques seront utilisées à la place, en fonction de la valeur du champ use_geodesic_distances. Si ce champ n'est pas vide, use_geodesic_distances ne peut pas être défini sur "true", et ni duration_distance_matrix_src_tags ni duration_distance_matrix_dst_tags ne peuvent être vides. Exemples d'utilisation : Il existe deux emplacements : locA et locB. Un véhicule commençant son itinéraire à locA et le terminant à locA. 1 demande de visite de collecte à locB. model { vehicles { start_tags: "locA" end_tags: "locA" } shipments { pickups { tags: "locB" } } duration_distance_matrix_src_tags: "locA" duration_distance_matrix_src_tags: "locB" duration_distance_matrix_dst_tags: "locA" duration_distance_matrix_dst_tags: "locB" duration_distance_matrices { rows { # from: locA durations { seconds: 0 } meters: 0 # to: locA durations { seconds: 100 } meters: 1000 # to: locB } rows { # from: locB durations { seconds: 102 } meters: 990 # to: locA durations { seconds: 0 } meters: 0 # to: locB } } } Il existe trois emplacements : locA, locB et locC. Un véhicule commençant son itinéraire à locA et le terminant à locB, en utilisant la matrice "fast". Un véhicule commençant son itinéraire à locB et le terminant à locB, en utilisant la matrice "slow". Un véhicule commençant son itinéraire à locB et le terminant à locB, en utilisant la matrice "fast". 1 demande de visite de collecte à locC. model { vehicles { start_tags: "locA" end_tags: "locB" start_tags: "fast" } vehicles { start_tags: "locB" end_tags: "locB" start_tags: "slow" } vehicles { start_tags: "locB" end_tags: "locB" start_tags: "fast" } shipments { pickups { tags: "locC" } } duration_distance_matrix_src_tags: "locA" duration_distance_matrix_src_tags: "locB" duration_distance_matrix_src_tags: "locC" duration_distance_matrix_dst_tags: "locB" duration_distance_matrix_dst_tags: "locC" duration_distance_matrices { vehicle_start_tag: "fast" rows { # from: locA durations { seconds: 1000 } meters: 2000 # to: locB durations { seconds: 600 } meters: 1000 # to: locC } rows { # from: locB durations { seconds: 0 } meters: 0 # to: locB durations { seconds: 700 } meters: 1200 # to: locC } rows { # from: locC durations { seconds: 702 } meters: 1190 # to: locB durations { seconds: 0 } meters: 0 # to: locC } } duration_distance_matrices { vehicle_start_tag: "slow" rows { # from: locA durations { seconds: 1800 } meters: 2001 # to: locB durations { seconds: 900 } meters: 1002 # to: locC } rows { # from: locB durations { seconds: 0 } meters: 0 # to: locB durations { seconds: 1000 } meters: 1202 # to: locC } rows { # from: locC durations { seconds: 1001 } meters: 1195 # to: locB durations { seconds: 0 } meters: 0 # to: locC } } }
duration_distance_matrix_src_tags[]	string Tags définissant les sources des matrices de durée et de distance ; duration_distance_matrices(i).rows(j) définit les durées et les distances entre les visites avec le tag duration_distance_matrix_src_tags(j) et les autres visites de la matrice i. Les tags correspondent à VisitRequest.tags ou Vehicle.start_tags. Un VisitRequest ou un Vehicle donné doit correspondre exactement à un tag de ce champ. Notez que les tags source, de destination et de matrice d'un Vehicle peuvent être identiques. De même, les tags source et de destination d'un VisitRequest peuvent être identiques. Tous les tags doivent être différents et ne peuvent pas être des chaînes vides. Si ce champ n'est pas vide, duration_distance_matrices ne doit pas l'être non plus.
duration_distance_matrix_dst_tags[]	string Tags définissant les destinations des matrices de durée et de distance ; duration_distance_matrices(i).rows(j).durations(k) (resp. duration_distance_matrices(i).rows(j).meters(k)) définit la durée (resp. la distance) du trajet entre les visites avec le tag duration_distance_matrix_src_tags(j) et les visites avec le tag duration_distance_matrix_dst_tags(k) dans la matrice i. Les tags correspondent à VisitRequest.tags ou Vehicle.start_tags. Un VisitRequest ou un Vehicle donné doit correspondre exactement à un tag de ce champ. Notez que les tags source, de destination et de matrice d'un Vehicle peuvent être identiques. De même, les tags source et de destination d'un VisitRequest peuvent être identiques. Tous les tags doivent être différents et ne peuvent pas être des chaînes vides. Si ce champ n'est pas vide, duration_distance_matrices ne doit pas l'être non plus.
transition_attributes[]	TransitionAttributes Attributs de transition ajoutés au modèle.
shipment_type_incompatibilities[]	ShipmentTypeIncompatibility Ensembles de shipment_types incompatibles (voir ShipmentTypeIncompatibility).
shipment_type_requirements[]	ShipmentTypeRequirement Ensembles d'exigences shipment_type (voir ShipmentTypeRequirement).
precedence_rules[]	PrecedenceRule Ensemble de règles de priorité qui doivent être appliquées dans le modèle. IMPORTANT : L'utilisation de règles de priorité limite la taille du problème pouvant être optimisé. Les requêtes utilisant des règles de priorité qui incluent de nombreux envois peuvent être refusées.
max_active_vehicles	int32 Limite le nombre maximal de véhicules actifs. Un véhicule est actif si son itinéraire effectue au moins un envoi. Cela peut être utilisé pour limiter le nombre d'itinéraires lorsque le nombre de conducteurs est inférieur au nombre de véhicules et que la flotte de véhicules est hétérogène. L'optimisation sélectionnera ensuite le meilleur sous-ensemble de véhicules à utiliser. Doit être strictement positif.

DurationDistanceMatrix

Spécifie une matrice de durée et de distance entre les lieux de départ des visites et des véhicules et les lieux d'arrivée des visites et des véhicules.

Champs
rows[]	Row Spécifie les lignes de la matrice de durée et de distance. Il doit comporter autant d'éléments que ShipmentModel.duration_distance_matrix_src_tags.
vehicle_start_tag	string Tag définissant les véhicules auxquels cette matrice de durée et de distance s'applique. Si ce champ est vide, la matrice s'applique à tous les véhicules, et il ne peut y avoir qu'une seule matrice. Chaque départ de véhicule doit correspondre à une seule matrice, c'est-à-dire qu'un seul de ses champs start_tags doit correspondre au champ vehicle_start_tag d'une matrice (et de cette matrice uniquement). Toutes les matrices doivent avoir un vehicle_start_tag différent.

Ligne

Spécifie une ligne de la matrice de durée et de distance.

Champs
durations[]	Duration Valeurs de durée pour une ligne donnée. Il doit comporter autant d'éléments que ShipmentModel.duration_distance_matrix_dst_tags.
meters[]	double Valeurs de distance pour une ligne donnée. Si aucun coût ni aucune contrainte ne font référence à des distances dans le modèle, ce champ peut être laissé vide. Sinon, il doit comporter autant d'éléments que durations.

Objectif

Les objectifs remplacent complètement le modèle de coût et sont donc incompatibles avec les coûts préexistants. Chaque objectif correspond à un certain nombre de coûts prédéfinis, par exemple pour les véhicules, les envois ou les attributs de transition.

Expérimental : pour en savoir plus, consultez https://developers.google.com/maps/tt/route-optimization/experimental/objectives/make-request.

Champs
type	Type Type de l'objectif.
weight	double Poids de cet objectif par rapport aux autres. Il peut s'agir de n'importe quel nombre non négatif. La somme des pondérations ne doit pas nécessairement être égale à 1. La valeur par défaut des pondérations est 1.0.

Type

Type d'objectif qui sera mappé à un ensemble de coûts.

Enums
DEFAULT	Un ensemble de coûts par défaut sera utilisé pour garantir une solution raisonnable. Remarque : Cet objectif peut être utilisé seul, mais il sera également toujours ajouté avec une pondération de 1,0, comme référence, aux objectifs spécifiés par l'utilisateur, s'il n'est pas déjà présent.
MIN_DISTANCE	"MIN". Réduire la distance totale parcourue.
MIN_WORKING_TIME	Réduire le temps de travail total, additionné pour tous les véhicules.
MIN_TRAVEL_TIME	Identique à ce qui précède, mais en se concentrant uniquement sur le temps de trajet.
MIN_NUM_VEHICLES	Réduire le nombre de véhicules utilisés.

PrecedenceRule

Règle de priorité entre deux événements (chaque événement correspond à l'enlèvement ou à la livraison d'un envoi) : le "deuxième" événement doit commencer au moins offset_duration après le début du "premier".

Plusieurs précédences peuvent faire référence aux mêmes événements (ou à des événements associés), par exemple "la prise en charge de B a lieu après la livraison de A" et "la prise en charge de C a lieu après la prise en charge de B".

De plus, les priorités ne s'appliquent que lorsque les deux envois sont effectués. Sinon, elles sont ignorées.

Champs
first_is_delivery	bool Indique si le "premier" événement est une livraison.
second_is_delivery	bool Indique si le "deuxième" événement est une livraison.
offset_duration	Duration Décalage entre le "premier" et le "deuxième" événement. Il peut être négatif.
first_index	int32 Index d'envoi du "premier" événement. Vous devez spécifier ce champ.
second_index	int32 Index d'envoi du "deuxième" événement. Vous devez spécifier ce champ.

ShipmentRoute

L'itinéraire d'un véhicule peut être décomposé, le long de l'axe temporel, comme suit (nous supposons qu'il y a n visites) :

  |            |            |          |       |  T[2], |        |      |
  | Transition |  Visit #0  |          |       |  V[2], |        |      |
  |     #0     |    aka     |   T[1]   |  V[1] |  ...   | V[n-1] | T[n] |
  |  aka T[0]  |    V[0]    |          |       | V[n-2],|        |      |
  |            |            |          |       | T[n-1] |        |      |
  ^            ^            ^          ^       ^        ^        ^      ^
vehicle    V[0].start   V[0].end     V[1].   V[1].    V[n].    V[n]. vehicle
 start     (arrival)   (departure)   start   end      start    end     end

Notez que nous faisons une distinction entre :

• "événements ponctuels", tels que le début et la fin du véhicule, ainsi que le début et la fin de chaque visite (c'est-à-dire l'arrivée et le départ). Ils se produisent à une seconde donnée.
• "intervalles de temps", comme les visites elles-mêmes et la transition entre les visites. Bien que les intervalles de temps puissent parfois avoir une durée nulle, c'est-à-dire commencer et se terminer à la même seconde, ils ont souvent une durée positive.

Règles invariantes :

• S'il y a n visites, il y a n+1 transitions.
• Une visite est toujours précédée d'une transition (même index) et suivie d'une transition (index + 1).
• Le démarrage du véhicule est toujours suivi de la transition 0.
• La fin du véhicule est toujours précédée de la transition #n.

Voici ce qui se passe lors d'un Transition et d'un Visit :

---+-------------------------------------+-----------------------------+-->
   |           TRANSITION[i]             |           VISIT[i]          |
   |                                     |                             |
   |  * TRAVEL: the vehicle moves from   |      PERFORM the visit:     |
   |    VISIT[i-1].departure_location to |                             |
   |    VISIT[i].arrival_location, which |  * Spend some time:         |
   |    takes a given travel duration    |    the "visit duration".    |
   |    and distance                     |                             |
   |                                     |  * Load or unload           |
   |  * BREAKS: the driver may have      |    some quantities from the |
   |    breaks (e.g. lunch break).       |    vehicle: the "demand".   |
   |                                     |                             |
   |  * WAIT: the driver/vehicle does    |                             |
   |    nothing. This can happen for     |                             |
   |    many reasons, for example when   |                             |
   |    the vehicle reaches the next     |                             |
   |    event's destination before the   |                             |
   |    start of its time window         |                             |
   |                                     |                             |
   |  * DELAY: *right before* the next   |                             |
   |    arrival. E.g. the vehicle and/or |                             |
   |    driver spends time unloading.    |                             |
   |                                     |                             |
---+-------------------------------------+-----------------------------+-->
   ^                                     ^                             ^
V[i-1].end                           V[i].start                    V[i].end

Enfin, voici comment les états TRAVEL, BREAKS, DELAY et WAIT peuvent être organisés lors d'une transition.

• Ils ne se chevauchent pas.
• Le DELAY est unique et doit être une période de temps contiguë juste avant la prochaine visite (ou la fin du véhicule). Il suffit donc de connaître la durée du retard pour connaître ses heures de début et de fin.
• Les PAUSES sont des périodes contiguës qui ne se chevauchent pas. La réponse spécifie l'heure de début et la durée de chaque pause.
• TRAVEL et WAIT sont "préemptibles" : ils peuvent être interrompus plusieurs fois pendant cette transition. Les clients peuvent supposer que le trajet se déroule "dès que possible" et que l'attente remplit le temps restant.

Exemple (complexe) :

                               TRANSITION[i]
--++-----+-----------------------------------------------------------++-->
  ||     |       |           |       |           |         |         ||
  ||  T  |   B   |     T     |       |     B     |         |    D    ||
  ||  r  |   r   |     r     |   W   |     r     |    W    |    e    ||
  ||  a  |   e   |     a     |   a   |     e     |    a    |    l    ||
  ||  v  |   a   |     v     |   i   |     a     |    i    |    a    ||
  ||  e  |   k   |     e     |   t   |     k     |    t    |    y    ||
  ||  l  |       |     l     |       |           |         |         ||
  ||     |       |           |       |           |         |         ||
--++-----------------------------------------------------------------++-->

Champs
vehicle_index	int32 Véhicule effectuant l'itinéraire, identifié par son index dans la source ShipmentModel.
vehicle_label	string Libellé du véhicule effectuant cet itinéraire, égal à ShipmentModel.vehicles(vehicle_index).label, s'il est spécifié.
vehicle_start_time	Timestamp Heure à laquelle le véhicule commence son itinéraire.
vehicle_end_time	Timestamp Heure à laquelle le véhicule termine son itinéraire.
visits[]	Visit Séquence ordonnée de visites représentant un itinéraire. visits[i] est la i-ème visite de l'itinéraire. Si ce champ est vide, le véhicule est considéré comme inutilisé.
transitions[]	Transition Liste ordonnée des transitions pour l'itinéraire.
has_traffic_infeasibilities	bool Lorsque OptimizeToursRequest.consider_road_traffic est défini sur "true", ce champ indique que les incohérences dans les horaires des itinéraires sont prédites à l'aide d'estimations de la durée du trajet basées sur le trafic. Il se peut que le temps soit insuffisant pour effectuer les trajets ajustés en fonction du trafic, les retards et les pauses entre les visites, avant la première visite ou après la dernière visite, tout en respectant les périodes de visite et de véhicule. Par exemple, start_time(previous_visit) + duration(previous_visit) + travel_duration(previous_visit, next_visit) > start_time(next_visit) L'arrivée à next_visit aura probablement lieu après la période actuelle en raison de l'augmentation du temps de trajet estimé travel_duration(previous_visit, next_visit) due au trafic. De plus, une pause peut être forcée à chevaucher une visite en raison d'une augmentation des estimations de temps de trajet et des restrictions de créneau horaire de visite ou de pause.
route_polyline	EncodedPolyline Représentation de l'itinéraire sous forme de polyligne encodée. Ce champ n'est renseigné que si OptimizeToursRequest.populate_polylines est défini sur "true".
breaks[]	Break Pauses programmées pour le véhicule effectuant cet itinéraire. La séquence breaks représente des intervalles de temps, chacun commençant à la valeur start_time correspondante et durant duration secondes.
metrics	AggregatedMetrics Métriques de durée, de distance et de charge pour cet itinéraire. Les champs de AggregatedMetrics sont additionnés pour tous les ShipmentRoute.transitions ou ShipmentRoute.visits, selon le contexte.
vehicle_fullness	VehicleFullness Champ VehicleFullness pour calculer la proximité des métriques limitées par rapport à leurs limites de véhicule respectives. Ses champs sont des ratios entre un champ de métrique plafonné (par exemple, AggregatedMetrics.travel_distance_meters) et la limite de véhicule associée (par exemple, Vehicle.route_distance_limit). Expérimental : le comportement ou l'existence de ce champ peuvent changer à l'avenir.
route_costs	map<string, double> Coût de l'itinéraire, réparti par champs de requête liés au coût. Les clés sont des chemins d'accès proto, relatifs à la requête OptimizeToursRequest d'entrée, par exemple "model.shipments.pickups.cost", et les valeurs correspondent au coût total généré par le champ de coût correspondant, agrégé sur l'ensemble de l'itinéraire. En d'autres termes, costs["model.shipments.pickups.cost"] est la somme de tous les coûts de retrait sur l'itinéraire. Tous les coûts définis dans le modèle sont indiqués en détail ici, à l'exception de ceux liés aux TransitionAttributes, qui ne sont indiqués que de manière agrégée à partir de janvier 2022.
route_total_cost	double Coût total de l'itinéraire. Somme de tous les coûts de la carte des coûts.

Pause

Données représentant l'exécution d'une pause.

Champs
start_time	Timestamp Heure de début d'une pause.
duration	Duration Durée d'une pause.

EncodedPolyline

Représentation encodée d'une polyligne. Pour en savoir plus sur l'encodage des polylignes, consultez https://developers.google.com/maps/documentation/utilities/polylinealgorithm et https://developers.google.com/maps/documentation/javascript/reference/geometry#encoding.

Champs
points	string Chaîne représentant les points encodés de la polyligne.

Transition

Transition entre deux événements sur l'itinéraire. Consultez la description de ShipmentRoute.

Si le véhicule n'a pas de start_location et/ou de end_location, les métriques de trajet correspondantes sont définies sur 0.

Champs
travel_duration	Duration Durée du trajet pendant cette transition.
travel_distance_meters	double Distance parcourue pendant la transition.
traffic_info_unavailable	bool Lorsque le trafic est demandé via OptimizeToursRequest.consider_road_traffic et que les informations sur le trafic n'ont pas pu être récupérées pour un Transition, cette valeur booléenne est définie sur "true". Cela peut être temporaire (problème rare au niveau des serveurs de trafic en temps réel) ou permanent (aucune donnée pour cet emplacement).
delay_duration	Duration Somme des durées de délai appliquées à cette transition. Le cas échéant, le délai commence exactement delay_duration secondes avant l'événement suivant (visite ou fin du véhicule). Consultez les TransitionAttributes.delay.
break_duration	Duration Somme de la durée des pauses survenant pendant cette transition, le cas échéant. Les détails concernant l'heure de début et la durée de chaque coupure sont stockés dans ShipmentRoute.breaks.
wait_duration	Duration Temps d'attente pendant cette transition. La durée d'attente correspond au temps d'inactivité et n'inclut pas les pauses. Notez également que ce temps d'attente peut être divisé en plusieurs intervalles non contigus.
total_duration	Duration Durée totale de la transition, fournie pour plus de commodité. Il est égal à : start_time de la prochaine visite (ou vehicle_end_time s'il s'agit de la dernière transition) - start_time de cette transition ; Si ShipmentRoute.has_traffic_infeasibilities est défini sur "false", la condition suivante s'applique également : total_duration = travel_duration + delay_duration break_duration + wait_duration`.
start_time	Timestamp Heure de début de cette transition.
route_polyline	EncodedPolyline Représentation de la polyligne encodée de l'itinéraire suivi pendant la transition. Ce champ n'est renseigné que si populate_transition_polylines est défini sur "true".
route_token	string Uniquement en sortie. Jeton opaque pouvant être transmis au SDK Navigation pour reconstruire l'itinéraire pendant la navigation et, en cas de changement d'itinéraire, respecter l'intention d'origine lors de la création de l'itinéraire. Traitez ce jeton comme un blob opaque. Ne comparez pas sa valeur entre les requêtes, car elle peut changer même si le service renvoie exactement le même itinéraire. Ce champ n'est renseigné que si populate_transition_polylines est défini sur "true".
vehicle_loads	map<string, VehicleLoad> Charges du véhicule pendant cette transition, pour chaque type qui apparaît dans le champ Vehicle.load_limits de ce véhicule ou qui présente une valeur Shipment.load_demands non nulle pour un envoi effectué sur cet itinéraire. Les charges lors de la première transition sont les charges de départ de l'itinéraire du véhicule. Ensuite, après chaque visite, les load_demands de la visite sont ajoutés ou soustraits pour obtenir les charges de la transition suivante, selon que la visite était un retrait ou une livraison.

VehicleLoad

Indique la charge réelle du véhicule à un certain point de l'itinéraire, pour un type donné (voir Transition.vehicle_loads).

Champs
amount	int64 Quantité de charge sur le véhicule, pour le type donné. L'unité de charge est généralement indiquée par le type. Consultez les Transition.vehicle_loads.

Consulter

Visite effectuée au cours d'un itinéraire. Cette visite correspond à un retrait ou à une livraison d'un Shipment.

Champs
shipment_index	int32 Index du champ shipments dans la source ShipmentModel.
is_pickup	bool Si la valeur est "true", la visite correspond à un retrait d'un Shipment. Sinon, il correspond à une livraison.
visit_request_index	int32 Index de VisitRequest dans le champ de retrait ou de livraison de Shipment (voir is_pickup).
start_time	Timestamp Heure à laquelle la visite commence. Notez que le véhicule peut arriver plus tôt que prévu sur le lieu de la visite. Les heures sont cohérentes avec le ShipmentModel.
load_demands	map<string, Load> Demande de charge totale de la visite, calculée comme la somme de l'envoi et de la demande de visite load_demands. Les valeurs sont négatives si la visite est une livraison. Les demandes sont enregistrées pour les mêmes types que Transition.loads (voir ce champ).
detour	Duration Temps de détour supplémentaire dû aux envois visités sur l'itinéraire avant la visite et au temps d'attente potentiel induit par les créneaux horaires. Si la visite est une livraison, le détour est calculé à partir de la visite d'enlèvement correspondante et est égal à : start_time(delivery) - start_time(pickup) - (duration(pickup) + travel duration from the pickup location to the delivery location). Sinon, elle est calculée à partir de la valeur start_location du véhicule et est égale à : start_time - vehicle_start_time - travel duration from the vehicle's `start_location` to the visit.
shipment_label	string Copie du Shipment.label correspondant, s'il est spécifié dans le Shipment.
visit_label	string Copie du VisitRequest.label correspondant, s'il est spécifié dans le VisitRequest.
visit_type	VisitType Facultatif. Spécifie le type de visite. Remplace le champ Visit.is_pickup.
injected_solution_location_token	int32 Jeton opaque représentant des informations sur un lieu visité. Ce champ peut être renseigné dans les visites des itinéraires de résultat lorsque VisitRequest.avoid_u_turns a été défini sur "true" pour cette visite ou si ShipmentModel.avoid_u_turns a été défini sur "true" dans la requête OptimizeToursRequest. Expérimental : pour en savoir plus, consultez https://developers.google.com/maps/tt/route-optimization/experimental/u-turn-avoidance/make-request.

VisitType

Indique si la visite est un retrait, une livraison ou une visite d'un Stop. Les visites d'un arrêt ne sont utilisées que lorsque l'optimisation multimodale est activée.

Enums
VISIT_TYPE_UNSPECIFIED	Type de visite non spécifié.
PICKUP_SHIPMENT	La visite correspond à un retrait de colis.
DELIVER_SHIPMENT	La visite correspond à la livraison d'un colis.

ShipmentTypeIncompatibility

Spécifie les incompatibilités entre les envois en fonction de leur shipment_type. L'apparition d'envois incompatibles sur le même itinéraire est limitée en fonction du mode d'incompatibilité.

Champs
types[]	string Liste des types incompatibles. Deux envois ayant des shipment_types différents parmi ceux listés sont "incompatibles".
incompatibility_mode	IncompatibilityMode Mode appliqué à l'incompatibilité.

IncompatibilityMode

Modes définissant la manière dont l'apparence des envois incompatibles est limitée sur un même itinéraire.

Enums
INCOMPATIBILITY_MODE_UNSPECIFIED	Mode d'incompatibilité non spécifié. Cette valeur ne doit jamais être utilisée.
NOT_PERFORMED_BY_SAME_VEHICLE	Dans ce mode, deux envois de types incompatibles ne peuvent jamais partager le même véhicule.
NOT_IN_SAME_VEHICLE_SIMULTANEOUSLY	Dans ce mode, deux envois de types incompatibles ne peuvent jamais se trouver dans le même véhicule en même temps : Ils ne peuvent partager le même véhicule que si l'un est livré avant que l'autre ne soit récupéré. Lorsque les deux envois sont des collectes uniquement (pas de livraisons) ou des livraisons uniquement (pas de collectes), ils ne peuvent pas partager le même véhicule.

ShipmentTypeRequirement

Spécifie les exigences entre les envois en fonction de leur shipment_type. Les spécificités de l'exigence sont définies par le mode d'exigence.

Champs
required_shipment_type_alternatives[]	string Liste des types d'envoi alternatifs requis par dependent_shipment_types.
dependent_shipment_types[]	string Tous les envois avec un type dans le champ dependent_shipment_types nécessitent qu'au moins un envoi de type required_shipment_type_alternatives soit visité sur le même itinéraire. REMARQUE : Les chaînes d'exigences telles qu'un shipment_type dépend de lui-même ne sont pas autorisées.
requirement_mode	RequirementMode Mode appliqué à l'exigence.

RequirementMode

Modes définissant l'apparence des envois dépendants sur un itinéraire.

Enums
REQUIREMENT_MODE_UNSPECIFIED	Mode d'exigence non spécifié. Cette valeur ne doit jamais être utilisée.
PERFORMED_BY_SAME_VEHICLE	Dans ce mode, tous les envois "dépendants" doivent partager le même véhicule qu'au moins un de leurs envois "requis".
IN_SAME_VEHICLE_AT_PICKUP_TIME	En mode IN_SAME_VEHICLE_AT_PICKUP_TIME, tous les envois "dépendants" doivent avoir au moins un envoi "obligatoire" dans leur véhicule au moment de leur retrait. Un retrait de colis "dépendant" doit donc comporter : Un envoi "obligatoire" de type livraison uniquement livré sur l'itinéraire après, ou Un envoi "obligatoire" récupéré sur l'itinéraire avant lui, et si l'envoi "obligatoire" est associé à une livraison, celle-ci doit être effectuée après la récupération de l'envoi "dépendant".
IN_SAME_VEHICLE_AT_DELIVERY_TIME	Comme précédemment, sauf que les envois "dépendants" doivent avoir un envoi "requis" sur leur véhicule au moment de leur livraison.

SkippedShipment

Spécifie les détails des livraisons non effectuées dans une solution. Pour les cas simples et/ou si nous sommes en mesure d'identifier la cause de l'omission, nous l'indiquons ici.

Champs
index	int32 L'index correspond à l'index de l'envoi dans la source ShipmentModel.
label	string Copie du Shipment.label correspondant, s'il est spécifié dans le Shipment.
reasons[]	Reason Liste des raisons pour lesquelles l'envoi a été ignoré. Voir le commentaire ci-dessus Reason. Si nous ne parvenons pas à comprendre pourquoi un envoi a été ignoré, aucune raison ne sera définie.
penalty_cost	double Il s'agit d'une copie de Shipment.penalty_cost, incluse ici pour vous permettre de voir plus facilement la gravité d'un envoi ignoré. Expérimental : le comportement ou l'existence de ce champ peuvent changer à l'avenir.
estimated_incompatible_vehicle_ratio	double Ratio estimé de véhicules qui ne peuvent pas effectuer cet envoi pour au moins l'une des raisons ci-dessous. Remarque : Ce champ n'est renseigné que lorsque les raisons impliquent un véhicule. Expérimental : le comportement ou l'existence de ce champ peuvent changer à l'avenir.

Motif

Si nous pouvons expliquer pourquoi l'envoi a été ignoré, les raisons seront listées ici. Si la raison n'est pas la même pour tous les véhicules, reason comportera plusieurs éléments. Un envoi ignoré ne peut pas avoir de motifs en double, c'est-à-dire où tous les champs sont identiques, à l'exception de example_vehicle_index. Exemple :

reasons {
  code: DEMAND_EXCEEDS_VEHICLE_CAPACITY
  example_vehicle_index: 1
  example_exceeded_capacity_type: "Apples"
}
reasons {
  code: DEMAND_EXCEEDS_VEHICLE_CAPACITY
  example_vehicle_index: 3
  example_exceeded_capacity_type: "Pears"
}
reasons {
  code: CANNOT_BE_PERFORMED_WITHIN_VEHICLE_DISTANCE_LIMIT
  example_vehicle_index: 1
}

L'envoi ignoré n'est compatible avec aucun véhicule. Les raisons peuvent être différentes pour tous les véhicules, mais la capacité "Pommes " d'au moins un véhicule serait dépassée (y compris le véhicule 1), la capacité "Poires " d'au moins un véhicule serait dépassée (y compris le véhicule 3) et la limite de distance d'au moins un véhicule serait dépassée (y compris le véhicule 1).

Champs
code	Code Reportez-vous aux commentaires du code.
example_vehicle_indices[]	int32 Identique à example_vehicle_index, sauf que nous fournissons la liste des véhicules identifiés. Cette liste n'est pas nécessairement exhaustive. Ce champ n'est renseigné que si [fill_example_vehicle_indices_in_skipped_reasons][] est défini sur "true". Expérimental : le comportement ou l'existence de ce champ peuvent changer à l'avenir.
example_exceeded_capacity_type	string Si le code de motif est DEMAND_EXCEEDS_VEHICLE_CAPACITY, documente un type de capacité dépassé.
example_vehicle_index	int32 Si la raison est liée à une incompatibilité entre l'envoi et le véhicule, ce champ fournit l'index d'un véhicule pertinent.

Code

Code identifiant le type de motif. L'ordre n'a pas d'importance ici. En particulier, elle n'indique pas si une raison donnée apparaîtra avant une autre dans la solution, si les deux s'appliquent.

Enums
CODE_UNSPECIFIED	Cette valeur ne doit jamais être utilisée.
NO_VEHICLE	Il n'y a aucun véhicule dans le modèle, ce qui rend tous les envois impossibles.
DEMAND_EXCEEDS_VEHICLE_CAPACITY	La demande de l'envoi dépasse la capacité d'un véhicule pour certains types de capacité, dont example_exceeded_capacity_type.
CANNOT_BE_PERFORMED_WITHIN_VEHICLE_DISTANCE_LIMIT	La distance minimale nécessaire pour effectuer cet envoi, c'est-à-dire de l'emplacement start_location du véhicule aux lieux d'enlèvement et/ou de livraison de l'envoi et à l'emplacement de fin du véhicule, dépasse la valeur route_distance_limit du véhicule. Notez que pour ce calcul, nous utilisons les distances géodésiques.
CANNOT_BE_PERFORMED_WITHIN_VEHICLE_DURATION_LIMIT	Le temps minimal nécessaire pour effectuer cet envoi, y compris le temps de trajet, le temps d'attente et le temps de service, dépasse le route_duration_limit du véhicule. Remarque : Le temps de trajet est calculé dans le meilleur des cas, à savoir la distance géodésique x 36 m/s (environ 130 km/h).
CANNOT_BE_PERFORMED_WITHIN_VEHICLE_TRAVEL_DURATION_LIMIT	Comme ci-dessus, mais nous ne comparons que le temps de trajet minimal et le travel_duration_limit du véhicule.
CANNOT_BE_PERFORMED_WITHIN_VEHICLE_TIME_WINDOWS	Le véhicule ne peut pas effectuer cette livraison dans le meilleur des cas (voir CANNOT_BE_PERFORMED_WITHIN_VEHICLE_DURATION_LIMIT pour le calcul du temps) s'il commence à son heure de début la plus précoce : le temps total ferait que le véhicule se termine après son heure de fin la plus tardive.
VEHICLE_NOT_ALLOWED	Le champ allowed_vehicle_indices de l'envoi n'est pas vide et ce véhicule n'en fait pas partie.
VEHICLE_IGNORED	Le champ ignore du véhicule est défini sur "true". Expérimental : le comportement ou l'existence de ce champ peuvent changer à l'avenir.
SHIPMENT_IGNORED	Le champ ignore de l'envoi est défini sur "true". Expérimental : le comportement ou l'existence de ce champ peuvent changer à l'avenir.
SKIPPED_IN_INJECTED_SOLUTION_CONSTRAINT	L'envoi est ignoré dans injected_solution_constraint. Expérimental : le comportement ou l'existence de ce champ peuvent changer à l'avenir.
VEHICLE_ROUTE_IS_FULLY_SEQUENCE_CONSTRAINED	L'assouplissement de l'itinéraire du véhicule spécifié dans injected_solution_constraint ne permet pas d'insérer de visite. Expérimental : le comportement ou l'existence de ce champ peuvent changer à l'avenir.
ZERO_PENALTY_COST	L'envoi n'entraîne aucun coût de pénalité. Bien que cela puisse être utile en tant que choix de modélisation avancé, cela peut également expliquer après coup pourquoi un envoi a été ignoré. Expérimental : le comportement ou l'existence de ce champ peuvent changer à l'avenir.

TimeWindow

Les périodes limitent l'heure d'un événement, comme l'heure d'arrivée lors d'une visite, ou l'heure de début et de fin d'un véhicule.

Les limites strictes de la période, start_time et end_time, appliquent l'heure de début et de fin de l'événement, de sorte que start_time <= event_time <= end_time. La limite inférieure de la période flexible, soft_start_time, exprime une préférence pour que l'événement se produise à soft_start_time ou après, en entraînant un coût proportionnel au temps écoulé avant soft_start_time. La limite supérieure de la période flexible, soft_end_time, exprime une préférence pour que l'événement se produise au plus tard à soft_end_time, en entraînant un coût proportionnel au temps écoulé après soft_end_time. start_time, end_time, soft_start_time et soft_end_time doivent respecter les limites de temps globales (voir ShipmentModel.global_start_time et ShipmentModel.global_end_time) et les conditions suivantes :

  0 <= `start_time` <= `end_time` and
  0 <= `start_time` <= `soft_start_time` and
  0 <= `soft_end_time` <= `end_time`.

Champs
start_time	Timestamp Heure de début de l'intervalle de temps strict. Si aucune valeur n'est spécifiée, elle est définie sur ShipmentModel.global_start_time.
end_time	Timestamp Heure de fin de la période stricte. Si aucune valeur n'est spécifiée, elle est définie sur ShipmentModel.global_end_time.
soft_start_time	Timestamp Heure de début approximative de la période.
soft_end_time	Timestamp Heure de fin flexible de la période.
cost_per_hour_before_soft_start_time	double Coût par heure ajouté aux autres coûts du modèle si l'événement se produit avant soft_start_time, calculé comme suit : max(0, soft_start_time - t.seconds) * cost_per_hour_before_soft_start_time / 3600, t being the time of the event. Ce coût doit être positif, et le champ ne peut être défini que si "soft_start_time" a été défini.
cost_per_hour_after_soft_end_time	double Coût par heure ajouté aux autres coûts du modèle si l'événement se produit après soft_end_time, calculé comme suit : max(0, t.seconds - soft_end_time.seconds) * cost_per_hour_after_soft_end_time / 3600, t being the time of the event. Ce coût doit être positif, et le champ ne peut être défini que si soft_end_time a été défini.

TransitionAttributes

Spécifie les attributs des transitions entre deux visites consécutives sur un itinéraire. Plusieurs TransitionAttributes peuvent s'appliquer à la même transition. Dans ce cas, tous les coûts supplémentaires s'additionnent, et la contrainte ou la limite la plus stricte s'applique (selon la sémantique naturelle "ET").

Champs
src_tag	string Tags définissant l'ensemble des transitions (src->dst) auxquelles ces attributs s'appliquent. Une visite source ou un départ de véhicule correspond si et seulement si son VisitRequest.tags ou son Vehicle.start_tags contient src_tag ou ne contient pas excluded_src_tag (selon lequel de ces deux champs n'est pas vide).
excluded_src_tag	string Consultez les src_tag. Soit src_tag, soit excluded_src_tag doit être non vide.
dst_tag	string Une visite de destination ou une fin de véhicule correspond si son VisitRequest.tags ou son Vehicle.end_tags contient dst_tag ou ne contient pas excluded_dst_tag (selon lequel de ces deux champs n'est pas vide).
excluded_dst_tag	string Consultez les dst_tag. Soit dst_tag, soit excluded_dst_tag doit être non vide.
cost	double Spécifie un coût pour effectuer cette transition. Cette valeur est exprimée dans la même unité que tous les autres coûts du modèle et ne doit pas être négative. Il s'applique en plus de tous les autres coûts existants.
cost_per_kilometer	double Spécifie un coût par kilomètre appliqué à la distance parcourue lors de cette transition. Il s'ajoute à tout Vehicle.cost_per_kilometer spécifié sur les véhicules.
distance_limit	DistanceLimit Spécifie une limite pour la distance parcourue lors de cette transition. Depuis juin 2021, seules les limites souples sont acceptées.
delay	Duration Spécifie un délai encouru lors de l'exécution de cette transition. Ce délai se produit toujours après la fin de la visite source et avant le début de la visite de destination.

URI

URI (Uniform Resource Identifier) pointant vers une ressource pouvant être lue et écrite par l'API Route Optimization.

Champs

uri

string URI de la ressource. Il est possible que la ressource n'existe pas encore. Le contenu de la ressource est encodé au format JSON ou textproto. Seules les ressources Google Cloud Storage sont acceptées. Si la ressource est encodée au format JSON, son nom doit être suivi du suffixe .json. Si la ressource est encodée en tant que textproto, le nom de la ressource doit être suivi du suffixe .txtpb. Par exemple, l'URI Google Cloud Storage d'un fichier encodé au format JSON peut se présenter comme suit : gs://bucket/path/input/object.json.

Véhicule

Modélise un véhicule dans un problème d'expédition. La résolution d'un problème d'expédition créera un itinéraire commençant à start_location et se terminant à end_location pour ce véhicule. Un itinéraire est une séquence de visites (voir ShipmentRoute).

Champs
display_name	string Nom à afficher du véhicule défini par l'utilisateur. Il peut comporter jusqu'à 63 caractères et utiliser des caractères UTF-8.
travel_mode	TravelMode Mode de transport qui affecte les routes utilisables par le véhicule et sa vitesse. Consultez également travel_duration_multiple.
route_modifiers	RouteModifiers Ensemble de conditions à remplir qui affectent la façon dont les itinéraires sont calculés pour le véhicule donné.
start_location	LatLng Emplacement géographique où le véhicule démarre avant de récupérer des expéditions. Si aucune valeur n'est spécifiée, le véhicule démarre à sa première prise en charge. Si le modèle d'envoi comporte des matrices de durée et des matrices de distances, start_location ne doit pas être spécifié.
start_waypoint	Waypoint Point de cheminement représentant un emplacement géographique où le véhicule démarre avant de récupérer des expéditions. Si ni start_waypoint ni start_location n'est spécifié, le véhicule commence à sa première prise en charge. Si le modèle d'envoi comporte des matrices de durée et des matrices de distances, start_waypoint ne doit pas être spécifié.
end_location	LatLng Emplacement géographique où le véhicule s'arrête après avoir terminé sa dernière VisitRequest. Si ce paramètre n'est pas spécifié, le ShipmentRoute du véhicule se termine immédiatement lorsqu'il effectue sa dernière VisitRequest. Si le modèle d'envoi comporte des matrices de durée et des matrices de distances, end_location ne doit pas être spécifié.
end_waypoint	Waypoint Point de cheminement représentant un emplacement géographique où le véhicule s'arrête après avoir terminé sa dernière VisitRequest. Si ni end_waypoint ni end_location n'est spécifié, le ShipmentRoute du véhicule se termine immédiatement lorsqu'il termine sa dernière VisitRequest. Si le modèle d'envoi comporte des matrices de durée et des matrices de distances, end_waypoint ne doit pas être spécifié.
start_tags[]	string Spécifie les tags associés au début de l'itinéraire du véhicule. Les chaînes vides ou en double ne sont pas autorisées.
end_tags[]	string Spécifie les tags associés à la fin de l'itinéraire du véhicule. Les chaînes vides ou en double ne sont pas autorisées.
start_time_windows[]	TimeWindow Intervalles de temps pendant lesquels le véhicule peut quitter son point de départ. Ils doivent se situer dans les limites de temps globales (voir les champs ShipmentModel.global_*). Si aucune valeur n'est spécifiée, il n'y a pas de limite autre que ces limites de temps globales. Les périodes appartenant au même champ répété doivent être disjointes, c'est-à-dire qu'aucune période ne peut chevaucher une autre ni être adjacente à une autre, et qu'elles doivent être classées par ordre chronologique. cost_per_hour_after_soft_end_time et soft_end_time ne peuvent être définis que s'il n'y a qu'une seule période.
end_time_windows[]	TimeWindow Créneaux horaires pendant lesquels le véhicule peut arriver à son emplacement final. Ils doivent se situer dans les limites de temps globales (voir les champs ShipmentModel.global_*). Si aucune valeur n'est spécifiée, il n'y a pas d'autre limite que ces limites de temps globales. Les périodes appartenant au même champ répété doivent être disjointes, c'est-à-dire qu'aucune période ne peut chevaucher une autre ni être adjacente à une autre, et qu'elles doivent être classées par ordre chronologique. cost_per_hour_after_soft_end_time et soft_end_time ne peuvent être définis que s'il n'y a qu'une seule période.
unloading_policy	UnloadingPolicy Règle de déchargement appliquée au véhicule.
load_limits	map<string, LoadLimit> Capacités du véhicule (poids, volume, nombre de palettes, par exemple). Les clés de la carte sont les identifiants du type de charge, conformément aux clés du champ Shipment.load_demands. Si une clé donnée est absente de ce mappage, la capacité correspondante est considérée comme illimitée.
cost_per_hour	double Coûts du véhicule : tous les coûts s'additionnent et doivent être exprimés dans la même unité que Shipment.penalty_cost. Coût par heure de l'itinéraire du véhicule. Ce coût est appliqué à la durée totale de l'itinéraire, et inclut le temps de trajet, le temps d'attente et le temps de visite. L'utilisation de cost_per_hour au lieu de cost_per_traveled_hour peut entraîner une latence supplémentaire.
cost_per_traveled_hour	double Coût par heure de trajet de l'itinéraire du véhicule. Ce coût ne s'applique qu'au temps de trajet de l'itinéraire (c'est-à-dire celui indiqué dans ShipmentRoute.transitions) et exclut le temps d'attente et le temps de visite.
cost_per_kilometer	double Coût par kilomètre de l'itinéraire du véhicule. Ce coût est appliqué à la distance indiquée dans ShipmentRoute.transitions et ne s'applique pas à la distance parcourue implicitement entre arrival_location et departure_location d'un même VisitRequest.
fixed_cost	double Coût fixe appliqué si ce véhicule est utilisé pour gérer un envoi.
used_if_route_is_empty	bool Ce champ ne s'applique aux véhicules que lorsque leur itinéraire ne dessert aucun envoi. Indique si le véhicule doit être considéré comme d'occasion ou non dans ce cas. Si la valeur est "true", le véhicule se déplace de son point de départ à son point d'arrivée même s'il ne livre aucun envoi, et les coûts de temps et de distance résultant de son trajet départ --> arrivée sont pris en compte. Sinon, il ne se déplace pas de son point de départ à son point d'arrivée, et aucun break_rule ni retard (de TransitionAttributes) n'est prévu pour ce véhicule. Dans ce cas, le ShipmentRoute du véhicule ne contient aucune information, à l'exception de l'index et de l'étiquette du véhicule.
route_duration_limit	DurationLimit Limite appliquée à la durée totale de l'itinéraire du véhicule. Dans un OptimizeToursResponse donné, la durée de l'itinéraire d'un véhicule correspond à la différence entre son vehicle_end_time et son vehicle_start_time.
travel_duration_limit	DurationLimit Limite appliquée à la durée du trajet du véhicule. Dans un OptimizeToursResponse donné, la durée du trajet est la somme de tous ses transitions.travel_duration.
route_distance_limit	DistanceLimit Limite appliquée à la distance totale de l'itinéraire du véhicule. Dans un OptimizeToursResponse donné, la distance de l'itinéraire est la somme de toutes ses transitions.travel_distance_meters.
extra_visit_duration_for_visit_type	map<string, Duration> Spécifie un mappage des chaînes visit_types aux durées. La durée correspond au temps supplémentaire par rapport à VisitRequest.duration à prendre lors des visites avec le visit_types spécifié. Cette durée de visite supplémentaire entraîne des coûts si cost_per_hour est spécifié. Les clés (par exemple, visit_types) ne peuvent pas être des chaînes vides. Si une demande de visite comporte plusieurs types, une durée sera ajoutée pour chaque type sur la carte.
break_rule	BreakRule Décrit le planning des pauses à appliquer à ce véhicule. Si ce champ est vide, aucune pause ne sera programmée pour ce véhicule.
label	string Spécifie un libellé pour ce véhicule. Cette étiquette est renvoyée dans la réponse en tant que vehicle_label de l'élément ShipmentRoute correspondant.
ignore	bool Si la valeur est "true", used_if_route_is_empty doit être "false" et ce véhicule ne sera pas utilisé. Si un envoi est effectué par un véhicule ignoré dans injected_first_solution_routes, il est ignoré dans la première solution, mais peut être effectué dans la réponse. Si un envoi est effectué par un véhicule ignoré dans injected_solution_constraint et que tout retrait/livraison associé est contraint de rester sur le véhicule (c'est-à-dire qu'il n'est pas assoupli au niveau RELAX_ALL_AFTER_THRESHOLD), il est ignoré dans la réponse. Si un envoi comporte un champ allowed_vehicle_indices non vide et que tous les véhicules autorisés sont ignorés, il est ignoré dans la réponse.
travel_duration_multiple	double Spécifie un facteur multiplicatif qui peut être utilisé pour augmenter ou diminuer les temps de trajet de ce véhicule. Par exemple, si vous définissez cette valeur sur 2, cela signifie que ce véhicule est plus lent et que ses temps de trajet sont deux fois plus longs que ceux des véhicules standards. Ce multiple n'affecte pas la durée des visites. Cela a une incidence sur le coût si cost_per_hour ou cost_per_traveled_hour sont spécifiés. Cette valeur doit être comprise entre 0,001 et 1 000,0. Si ce champ n'est pas défini, le véhicule est standard et ce multiplicateur est considéré comme égal à 1, 0. AVERTISSEMENT : Les temps de trajet seront arrondis à la seconde la plus proche après l'application de ce multiple, mais avant d'effectuer toute opération numérique. Par conséquent, un petit multiple peut entraîner une perte de précision. Voir également extra_visit_duration_for_visit_type ci-dessous.

DurationLimit

Limite définissant une durée maximale de l'itinéraire d'un véhicule. Il peut être dur ou mou.

Lorsqu'un champ de limite souple est défini, le seuil maximal souple et le coût associé doivent être définis ensemble.

Champs
max_duration	Duration Limite stricte limitant la durée à max_duration au maximum.
soft_max_duration	Duration Limite souple n'imposant pas de durée maximale, mais qui, lorsqu'elle est dépassée, entraîne un coût pour l'itinéraire. Ce coût s'ajoute aux autres coûts définis dans le modèle, avec la même unité. S'il est défini, soft_max_duration doit être non négatif. Si max_duration est également défini, soft_max_duration doit être inférieur à max_duration.
quadratic_soft_max_duration	Duration Limite souple n'imposant pas de durée maximale, mais qui, lorsqu'elle est dépassée, entraîne un coût quadratique pour l'itinéraire. Ce coût s'ajoute aux autres coûts définis dans le modèle, avec la même unité. Si quadratic_soft_max_duration est défini, les conditions suivantes doivent être remplies : Il ne doit pas être négatif. max_duration doit être défini. quadratic_soft_max_duration doit être inférieur à max_duration. La différence ne doit pas dépasser un jour : max_duration - quadratic_soft_max_duration <= 86400 seconds
cost_per_hour_after_soft_max	double Coût horaire encouru si le seuil soft_max_duration est dépassé. Le coût supplémentaire est de 0 si la durée est inférieure au seuil. Sinon, le coût dépend de la durée, comme suit : cost_per_hour_after_soft_max * (duration - soft_max_duration) Le coût ne doit pas être négatif.
cost_per_square_hour_after_quadratic_soft_max	double Coût par heure au carré encouru si le seuil quadratic_soft_max_duration est dépassé. Le coût supplémentaire est de 0 si la durée est inférieure au seuil. Sinon, le coût dépend de la durée, comme suit : cost_per_square_hour_after_quadratic_soft_max * (duration - quadratic_soft_max_duration)^2 Le coût ne doit pas être négatif.

LoadLimit

Définit une limite de charge s'appliquant à un véhicule (par exemple, "ce camion ne peut transporter que 3 500 kg"). Consultez les load_limits.

Champs
soft_max_load	int64 Limite souple de la charge. Consultez les cost_per_unit_above_soft_max.
cost_per_unit_above_soft_max	double Si la charge dépasse soft_max_load sur l'itinéraire de ce véhicule, la pénalité de coût suivante s'applique (une seule fois par véhicule) : (charge - soft_max_load) * cost_per_unit_above_soft_max. Tous les coûts s'additionnent et doivent être exprimés dans la même unité que Shipment.penalty_cost. Les limites souples ne peuvent être définies que sur les types qui s'appliquent uniquement aux retraits ou uniquement aux livraisons dans l'ensemble du modèle.
start_load_interval	Interval Intervalle de charge acceptable du véhicule au début de l'itinéraire.
end_load_interval	Interval Intervalle de charge acceptable du véhicule à la fin de l'itinéraire.
max_load	int64 La quantité de charge maximale acceptable.
cost_per_kilometer	LoadCost Coût du déplacement d'une unité de charge sur un kilomètre pour ce véhicule. Cela peut être utilisé comme indicateur de la consommation de carburant : si la charge est un poids (en Newtons), alors charge*kilomètre a la dimension d'une énergie. Expérimental : pour en savoir plus, consultez https://developers.google.com/maps/tt/route-optimization/experimental/load-cost/make-request.
cost_per_traveled_hour	LoadCost Coût du transport d'une unité de charge pendant une heure pour ce véhicule. Expérimental : pour en savoir plus, consultez https://developers.google.com/maps/tt/route-optimization/experimental/load-cost/make-request.

Intervalle

Intervalle des montants de charge acceptables.

Champs
min	int64 Une charge minimale acceptable. Doit être ≥ 0. Si les deux sont spécifiés, min doit être inférieur ou égal à max.
max	int64 Une charge maximale acceptable. Doit être ≥ 0. Si ce paramètre n'est pas spécifié, la charge maximale n'est pas limitée par ce message. Si les deux sont spécifiés, min doit être inférieur ou égal à max.

LoadCost

Coût du déplacement d'une unité de charge pendant un Transition. Pour une charge donnée, le coût est la somme de deux parties :

• min(load, load_threshold) * cost_per_unit_below_threshold
• max(0, charge - load_threshold) * cost_per_unit_above_threshold

Avec ce coût, les solutions privilégient la livraison des demandes élevées en premier, ou, de manière équivalente, la collecte des demandes élevées en dernier. Par exemple, si un véhicule est équipé

load_limit {
  key: "weight"
  value {
    cost_per_kilometer {
      load_threshold: 15
      cost_per_unit_below_threshold: 2.0
      cost_per_unit_above_threshold: 10.0
    }
  }
}

et son itinéraire est start,pickup,pickup,delivery,delivery,end avec les transitions :

transition { vehicle_load['weight'] { amount: 0 }
             travel_distance_meters: 1000.0 }
transition { vehicle_load['weight'] { amount: 10 }
             travel_distance_meters: 1000.0 }
transition { vehicle_load['weight'] { amount: 20 }
             travel_distance_meters: 1000.0 }
transition { vehicle_load['weight'] { amount: 10 }
             travel_distance_meters: 1000.0 }
transition { vehicle_load['weight'] { amount: 0 }
             travel_distance_meters: 1000.0 }

alors le coût encouru par ce LoadCost est (cost_below * load_below * kilomètres + cost_above * load_above * kms)

• transition 0: 0.0
• transition 1 : 2,0 * 10 * 1,0 + 10,0 * 0 * 1,0 = 20,0
• transition 2 : 2,0 * 15 * 1,0 + 10,0 * (20 - 15) * 1,0 = 80,0
• transition 3 : 2,0 * 10 * 1,0 + 10,0 * 0 * 1,0 = 20,0
• transition 4: 0.0

La valeur de LoadCost sur la route est donc de 120,0.

Toutefois, si l'itinéraire est départ,prise en charge,livraison,prise en charge,livraison,fin avec les transitions :

transition { vehicle_load['weight'] { amount: 0 }
             travel_distance_meters: 1000.0 }
transition { vehicle_load['weight'] { amount: 10 }
             travel_distance_meters: 1000.0 }
transition { vehicle_load['weight'] { amount: 0 }
             travel_distance_meters: 1000.0 }
transition { vehicle_load['weight'] { amount: 10 }
             travel_distance_meters: 1000.0 }
transition { vehicle_load['weight'] { amount: 0 }
             travel_distance_meters: 1000.0 }

alors le coût de ce LoadCost est de

• transition 0: 0.0
• transition 1 : 2,0 * 10 * 1,0 + 10,0 * 0 * 1,0 = 20,0
• transition 2 : 0,0
• transition 3 : 2,0 * 10 * 1,0 + 10,0 * 0 * 1,0 = 20,0
• transition 4: 0.0

Ici, la valeur LoadCost sur l'itinéraire est de 40,0.

LoadCost rend les solutions avec des transitions lourdes plus coûteuses.

Expérimental : pour en savoir plus, consultez https://developers.google.com/maps/tt/route-optimization/experimental/load-cost/make-request.

Champs
load_threshold	int64 Quantité de charge au-dessus de laquelle le coût de déplacement d'une unité de charge passe de cost_per_unit_below_threshold à cost_per_unit_above_threshold. Doit être supérieur ou égal à 0.
cost_per_unit_below_threshold	double Coût du déplacement d'une unité de charge, pour chaque unité comprise entre 0 et le seuil. Doit être une valeur finie et supérieure ou égale à 0.
cost_per_unit_above_threshold	double Coût du déplacement d'une unité de charge, pour chaque unité au-dessus du seuil. Dans le cas particulier où le seuil est égal à 0, il s'agit d'un coût fixe par unité. Doit être une valeur finie et supérieure ou égale à 0.

TravelMode

Modes de transport pouvant être utilisés par les véhicules.

Il doit s'agir d'un sous-ensemble des modes de transport de l'API Routes de Google Maps Platform. Consultez https://developers.google.com/maps/documentation/routes/reference/rest/v2/RouteTravelMode.

Remarque : Les itinéraires WALKING sont en version bêta et peuvent parfois ne pas comporter de trottoirs ou de voies piétonnes clairs. Vous devez afficher cet avertissement pour tous les itinéraires à pied que vous affichez dans votre application.

Enums
TRAVEL_MODE_UNSPECIFIED	Mode de transport non spécifié, équivalent à DRIVING.
DRIVING	Mode de transport correspondant aux itinéraires routiers (voiture, etc.).
WALKING	Mode de transport correspondant à un itinéraire à pied.

UnloadingPolicy

Règle sur la façon dont un véhicule peut être déchargé. S'applique uniquement aux envois comportant à la fois un enlèvement et une livraison.

Les autres envois peuvent avoir lieu n'importe où sur l'itinéraire, indépendamment de unloading_policy.

Enums
UNLOADING_POLICY_UNSPECIFIED	Règle de déchargement non spécifiée : les livraisons doivent simplement avoir lieu après les collectes correspondantes.
LAST_IN_FIRST_OUT	Les livraisons doivent être effectuées dans l'ordre inverse des retraits
FIRST_IN_FIRST_OUT	Les livraisons doivent être effectuées dans le même ordre que les retraits

VehicleFullness

VehicleFullness est une métrique qui calcule le taux de remplissage d'un véhicule. Chaque champ VehicleFullness est compris entre 0 et 1, et est calculé comme le ratio entre un champ de métrique limité (par exemple, AggregatedMetrics.travel_distance_meters) et la limite de véhicule associée (par exemple, Vehicle.route_distance_limit), le cas échéant. Sinon, le taux de remplissage n'est pas défini. Si la limite est de 0, le champ est défini sur 1. Remarque : Lorsqu'un itinéraire est soumis à des impossibilités de trafic, certains taux de remplissage bruts peuvent dépasser 1,0 (par exemple, le véhicule peut dépasser sa limite de distance). Dans ce cas, nous limitons les valeurs de plénitude à 1,0.

Champs
max_fullness	double Maximum de tous les autres champs de ce message.
distance	double Le ratio entre AggregatedMetrics.travel_distance_meters et Vehicle.route_distance_limit. Si Vehicle.route_distance_limit n'est pas défini, ce champ ne sera pas défini.
travel_duration	double Rapport entre [AggregatedMetrics.travel_duration_seconds][] et Vehicle.travel_duration_limit. Si Vehicle.travel_duration_limit n'est pas défini, ce champ ne sera pas défini.
active_duration	double Rapport entre [AggregatedMetrics.total_duration_seconds][] et Vehicle.route_duration_limit. Si Vehicle.route_duration_limit n'est pas défini, ce champ ne sera pas défini.
max_load	double Ratio maximal parmi tous les types de [AggregatedMetrics.max_load][] et leur Vehicle.load_limits respectif. Si tous les champs Vehicle.load_limits ne sont pas définis, ce champ ne sera pas défini.
active_span	double Ratio (vehicle_end_time - vehicle_start_time) / (latest_vehicle_end_time - earliest_vehicle_start_time) pour un véhicule donné. Si le dénominateur n'est pas présent, il utilise (ShipmentModel.global_end_time - ShipmentModel.global_start_time) à la place.

Repère

Encapsule un point de cheminement. Les points de cheminement marquent les lieux d'arrivée et de départ des VisitRequests, ainsi que les lieux de départ et d'arrivée des véhicules.

Champs
side_of_road	bool Facultatif. Indique que l'emplacement de ce point de cheminement est destiné à indiquer une préférence pour que le véhicule s'arrête d'un côté particulier de la route. Lorsque vous définissez cette valeur, l'itinéraire passe par l'emplacement de sorte que le véhicule puisse s'arrêter du côté de la route vers lequel l'emplacement est orienté par rapport au centre de la route. Cette option ne fonctionne pas pour le mode de transport "WALKING".
vehicle_stopover	bool Indique que le point de cheminement est destiné à l'arrêt des véhicules, dans le but de prendre ou de déposer des passagers. Cette option ne fonctionne que pour le mode de transport "DRIVING" et lorsque "location_type" est défini sur "location". Expérimental : le comportement ou l'existence de ce champ peuvent changer à l'avenir.
Champ d'union location_type. Différentes façons de représenter un lieu. location_type ne peut être qu'un des éléments suivants :
location	Location Point spécifié à l'aide de coordonnées géographiques, y compris un cap facultatif.
place_id	string ID de lieu du point d'intérêt associé au point de cheminement. Lorsque vous utilisez un ID de lieu pour spécifier le lieu d'arrivée ou de départ d'une VisitRequest, utilisez un ID de lieu suffisamment spécifique pour déterminer un emplacement LatLng pour la navigation vers le lieu. Par exemple, un ID de lieu représentant un bâtiment est approprié, mais un ID de lieu représentant une route est déconseillé.