ShipmentModel

รูปแบบการจัดส่งประกอบด้วยชุดการจัดส่งที่ต้องทำโดยชุดยานพาหนะ โดยลดต้นทุนโดยรวมให้เหลือน้อยที่สุด ซึ่งก็คือผลรวมของรายการต่อไปนี้

  • ค่าใช้จ่ายในการกำหนดเส้นทางของยานพาหนะ (ผลรวมของต้นทุนต่อเวลาทั้งหมด ต้นทุนต่อเวลาเดินทาง และต้นทุนคงที่สำหรับยานพาหนะทั้งหมด)
  • บทลงโทษสำหรับการไม่ดำเนินการจัดส่ง
  • ค่าใช้จ่ายของระยะเวลาการจัดส่งทั่วโลก
การแสดง JSON 
{
  "shipments": [
    {
      object (Shipment)
    }
  ],
  "vehicles": [
    {
      object (Vehicle)
    }
  ],
  "objectives": [
    {
      object (Objective)
    }
  ],
  "globalStartTime": string,
  "globalEndTime": string,
  "globalDurationCostPerHour": number,
  "durationDistanceMatrices": [
    {
      object (DurationDistanceMatrix)
    }
  ],
  "durationDistanceMatrixSrcTags": [
    string
  ],
  "durationDistanceMatrixDstTags": [
    string
  ],
  "transitionAttributes": [
    {
      object (TransitionAttributes)
    }
  ],
  "shipmentTypeIncompatibilities": [
    {
      object (ShipmentTypeIncompatibility)
    }
  ],
  "shipmentTypeRequirements": [
    {
      object (ShipmentTypeRequirement)
    }
  ],
  "precedenceRules": [
    {
      object (PrecedenceRule)
    }
  ],
  "maxActiveVehicles": integer
}
ช่อง
shipments[]

object (Shipment)

ชุดการจัดส่งที่ต้องดำเนินการในโมเดล
vehicles[]

object (Vehicle)

ชุดยานพาหนะที่สามารถใช้เพื่อเข้าชม
objectives[]

object (Objective)

ชุดวัตถุประสงค์ของรูปแบบนี้ ซึ่งเราจะเปลี่ยนเป็นค่าใช้จ่าย หากไม่ได้เป็นค่าว่าง โมเดลอินพุตต้องไม่มีค่าใช้จ่าย หากต้องการดูคําขอที่แก้ไขแล้ว โปรดใช้ solvingMode = TRANSFORM_AND_RETURN_REQUEST โปรดทราบว่าคำขอจะไม่ได้รับการแก้ไขในกรณีนี้ ดูเอกสารประกอบที่เกี่ยวข้อง

เวอร์ชันทดลอง: ดูรายละเอียดเพิ่มเติมได้ที่ https://developers.google.com/maps/tt/route-optimization/experimental/objectives/make-request
globalStartTime

string (Timestamp format)

เวลาเริ่มต้นและสิ้นสุดแบบรวมของโมเดล: ระบบจะไม่ถือว่าเวลาที่อยู่นอกช่วงนี้ถูกต้อง

ช่วงเวลาของโมเดลต้องน้อยกว่า 1 ปี กล่าวคือ globalEndTime และ globalStartTime ต้องอยู่ในช่วง 31536000 วินาทีจากกัน

เมื่อใช้ช่อง cost_per_*hour คุณอาจต้องการตั้งค่าช่วงเวลานี้ให้สั้นลงเพื่อเพิ่มประสิทธิภาพ (เช่น หากคุณประมาณ 1 วัน คุณควรตั้งค่าขีดจํากัดเวลาส่วนกลางเป็นวันนั้น) หากไม่ได้ตั้งค่า ระบบจะใช้ 00:00:00 UTC, 1 มกราคม 1970 (เช่น วินาที: 0, นาโนวินาที: 0) เป็นค่าเริ่มต้น

ใช้ RFC 3339 ซึ่งเอาต์พุตที่สร้างขึ้นจะเป็นรูปแบบ Z-normalized เสมอ และใช้ตัวเลขทศนิยม 0, 3, 6 หรือ 9 ระบบยังยอมรับออฟเซตอื่นๆ นอกเหนือจาก "Z" ด้วย ตัวอย่างเช่น "2014-10-02T15:01:23Z", "2014-10-02T15:01:23.045123456Z" หรือ "2014-10-02T15:01:23+05:30"
globalEndTime

string (Timestamp format)

หากไม่ได้ตั้งค่า ระบบจะใช้ 00:00:00 UTC, 1 มกราคม 1971 (เช่น วินาที: 31536000, นีโอน: 0) เป็นค่าเริ่มต้น

ใช้ RFC 3339 ซึ่งเอาต์พุตที่สร้างขึ้นจะเป็นรูปแบบ Z-normalized เสมอ และใช้ตัวเลขทศนิยม 0, 3, 6 หรือ 9 ระบบยังยอมรับออฟเซตอื่นๆ นอกเหนือจาก "Z" ด้วย ตัวอย่างเช่น "2014-10-02T15:01:23Z", "2014-10-02T15:01:23.045123456Z" หรือ "2014-10-02T15:01:23+05:30"
globalDurationCostPerHour

number

"ระยะเวลาโดยรวม" ของแผนโดยรวมคือความแตกต่างระหว่างเวลาเริ่มต้นที่มีประสิทธิภาพเร็วที่สุดและเวลาสิ้นสุดที่มีประสิทธิภาพล่าสุดของยานพาหนะทั้งหมด ผู้ใช้สามารถกำหนดต้นทุนต่อชั่วโมงให้กับจำนวนดังกล่าวเพื่อพยายามเพิ่มประสิทธิภาพให้งานเสร็จเร็วที่สุด เป็นต้น ค่าใช้จ่ายนี้ต้องเป็นหน่วยเดียวกับ Shipment.penalty_cost
durationDistanceMatrices[]

object (DurationDistanceMatrix)

ระบุเมทริกซ์ระยะเวลาและระยะทางที่ใช้ในโมเดล หากช่องนี้ว่างเปล่า ระบบจะใช้ Google Maps หรือระยะทางเชิงเรขาคณิตแทน ทั้งนี้ขึ้นอยู่กับค่าของช่อง useGeodesicDistances หากไม่ว่างเปล่า useGeodesicDistances ต้องไม่เป็นจริง และ durationDistanceMatrixSrcTags หรือ durationDistanceMatrixDstTags ต้องไม่ว่างเปล่า

ตัวอย่างการใช้งาน

  • มีสถานที่ตั้ง 2 แห่ง ได้แก่ locA และ locB
  • ยานพาหนะ 1 คันที่เริ่มเส้นทางที่ locA และสิ้นสุดที่ locA
  • คำขอรับสินค้า 1 รายการที่ locB
model {
  vehicles { startTags: "locA"  endTags: "locA" }
  shipments { pickups { tags: "locB" } }
  durationDistanceMatrixSrcTags: "locA"
  durationDistanceMatrixSrcTags: "locB"
  durationDistanceMatrixDstTags: "locA"
  durationDistanceMatrixDstTags: "locB"
  durationDistanceMatrices {
    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
    }
  }
}
  • มีสถานที่ตั้ง 3 แห่ง ได้แก่ locA, locB และ locC
  • ยานพาหนะ 1 คันที่เริ่มเส้นทางที่ locA และสิ้นสุดที่ locB โดยใช้เมทริกซ์ "เร็ว"
  • ยานพาหนะ 1 คันที่เริ่มเส้นทางที่ locB และสิ้นสุดที่ locB โดยใช้เมทริกซ์ "ช้า"
  • ยานพาหนะ 1 คันที่เริ่มเส้นทางที่ locB และสิ้นสุดที่ locB โดยใช้เมทริกซ์ "เร็ว"
  • คำขอรับสินค้า 1 รายการที่ locC
model {
  vehicles { startTags: "locA" endTags: "locB" startTags: "fast" }
  vehicles { startTags: "locB" endTags: "locB" startTags: "slow" }
  vehicles { startTags: "locB" endTags: "locB" startTags: "fast" }
  shipments { pickups { tags: "locC" } }
  durationDistanceMatrixSrcTags: "locA"
  durationDistanceMatrixSrcTags: "locB"
  durationDistanceMatrixSrcTags: "locC"
  durationDistanceMatrixDstTags: "locB"
  durationDistanceMatrixDstTags: "locC"
  durationDistanceMatrices {
    vehicleStartTag: "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
    }
  }
  durationDistanceMatrices {
    vehicleStartTag: "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
    }
  }
}
durationDistanceMatrixSrcTags[]

string

แท็กที่กําหนดแหล่งที่มาของเมตริกระยะเวลาและระยะทาง durationDistanceMatrices(i).rows(j) กําหนดระยะเวลาและระยะทางจากการเข้าชมที่มีแท็ก durationDistanceMatrixSrcTags(j) ไปยังการเข้าชมอื่นๆ ในเมตริก i

แท็กสอดคล้องกับ VisitRequest.tags หรือ Vehicle.start_tags VisitRequest หรือ Vehicle หนึ่งๆ ต้องตรงกับแท็กเดียวในช่องนี้ โปรดทราบว่าแท็กต้นทาง ปลายทาง และเมทริกซ์ของ Vehicle อาจเหมือนกัน และแท็กต้นทางและปลายทางของ VisitRequest ก็อาจเหมือนกัน แท็กทั้งหมดต้องไม่ซ้ำกันและต้องไม่ใช่สตริงว่าง หากช่องนี้ไม่ว่างเปล่า durationDistanceMatrices ต้องไม่ว่างเปล่า
durationDistanceMatrixDstTags[]

string

แท็กที่กําหนดปลายทางของเมตริกระยะเวลาและระยะทาง durationDistanceMatrices(i).rows(j).durations(k) (resp. durationDistanceMatrices(i).rows(j).meters(k)) กำหนดระยะเวลา (หรือระยะทาง) ของการเดินทางจากการเข้าชมที่มีแท็ก durationDistanceMatrixSrcTags(j) ไปยังการเข้าชมที่มีแท็ก durationDistanceMatrixDstTags(k) ในเมทริกซ์ i

แท็กสอดคล้องกับ VisitRequest.tags หรือ Vehicle.start_tags VisitRequest หรือ Vehicle หนึ่งๆ ต้องตรงกับแท็กเดียวในช่องนี้ โปรดทราบว่าแท็กต้นทาง ปลายทาง และเมทริกซ์ของ Vehicle อาจเหมือนกัน และแท็กต้นทางและปลายทางของ VisitRequest ก็อาจเหมือนกัน แท็กทั้งหมดต้องไม่ซ้ำกันและต้องไม่ใช่สตริงว่าง หากช่องนี้ไม่ว่างเปล่า durationDistanceMatrices ต้องไม่ว่างเปล่า
transitionAttributes[]

object (TransitionAttributes)

เพิ่มแอตทริบิวต์ทรานซิชันลงในโมเดล
shipmentTypeIncompatibilities[]

object (ShipmentTypeIncompatibility)

ชุดของ shipment_types ที่ใช้ร่วมกันไม่ได้ (ดู ShipmentTypeIncompatibility)
shipmentTypeRequirements[]

object (ShipmentTypeRequirement)

ชุดข้อกำหนด shipmentType (ดู ShipmentTypeRequirement)
precedenceRules[]

object (PrecedenceRule)

ชุดกฎลําดับความสําคัญที่ต้องบังคับใช้ในโมเดล

สำคัญ: การใช้กฎลําดับความสําคัญจะจํากัดขนาดของปัญหาที่เพิ่มประสิทธิภาพได้ คำขอที่ใช้กฎลําดับความสําคัญซึ่งมีการจัดส่งหลายรายการอาจถูกปฏิเสธ
maxActiveVehicles

integer

จำกัดจำนวนยานพาหนะที่ใช้งานอยู่สูงสุด ยานพาหนะจะถือว่าใช้งานอยู่หากเส้นทางของยานพาหนะมีการจัดส่งอย่างน้อย 1 รายการ สามารถใช้เพื่อจำกัดจำนวนเส้นทางในกรณีที่มีคนขับน้อยกว่ายานพาหนะและกลุ่มยานพาหนะมีความหลากหลาย จากนั้นการเพิ่มประสิทธิภาพจะเลือกกลุ่มย่อยของยานพาหนะที่ดีที่สุดที่จะใช้ ต้องเป็นค่าบวก

การจัดส่ง

การจัดส่งสินค้ารายการเดียว ตั้งแต่การยกขึ้นรถไปจนถึงการนำส่ง เพื่อให้ระบบถือว่ามีการจัดส่งเกิดขึ้น รถคันเดียวต้องไปที่จุดรับสินค้าแห่งหนึ่ง (และลดกำลังการผลิตที่เหลือตามนั้น) จากนั้นไปที่จุดนำส่งแห่งหนึ่งในภายหลัง (และเพิ่มกำลังการผลิตที่เหลือตามนั้นอีกครั้ง)

การแสดง JSON 
{
  "displayName": string,
  "pickups": [
    {
      object (VisitRequest)
    }
  ],
  "deliveries": [
    {
      object (VisitRequest)
    }
  ],
  "loadDemands": {
    string: {
      object (Load)
    },
    ...
  },
  "allowedVehicleIndices": [
    integer
  ],
  "costsPerVehicle": [
    number
  ],
  "costsPerVehicleIndices": [
    integer
  ],
  "pickupToDeliveryAbsoluteDetourLimit": string,
  "pickupToDeliveryTimeLimit": string,
  "shipmentType": string,
  "label": string,
  "ignore": boolean,
  "penaltyCost": number,
  "pickupToDeliveryRelativeDetourLimit": number
}
ช่อง
displayName

string

ชื่อที่แสดงของการจัดส่งที่ผู้ใช้กำหนด โดยชื่อมีความยาวได้สูงสุด 63 อักขระ และใช้อักขระ UTF-8 ได้
pickups[]

object (VisitRequest)

ชุดตัวเลือกการรับพัสดุที่เชื่อมโยงกับการจัดส่ง หากไม่ได้ระบุ ยานพาหนะจะต้องไปที่สถานที่ที่สอดคล้องกับการนำส่งเท่านั้น
deliveries[]

object (VisitRequest)

ชุดตัวเลือกการนำส่งที่เชื่อมโยงกับการจัดส่ง หากไม่ได้ระบุ ยานพาหนะจะต้องไปที่สถานที่ที่สอดคล้องกับการรับส่งเท่านั้น
loadDemands

map (key: string, value: object (Load))

ความต้องการในการบรรทุกของการจัดส่ง (เช่น น้ำหนัก ปริมาณ จำนวนพาเลต ฯลฯ) คีย์ในการแมปควรเป็นตัวระบุที่อธิบายประเภทของโหลดที่เกี่ยวข้อง และควรระบุหน่วยด้วย เช่น "weight_kg", "volume_gallons", "pallet_count" เป็นต้น หากคีย์หนึ่งๆ ไม่ปรากฏในการแมป ระบบจะถือว่าการโหลดที่เกี่ยวข้องเป็นค่าว่าง
allowedVehicleIndices[]

integer

ชุดยานพาหนะที่อาจทำการขนส่งนี้ หากเป็นค่าว่าง หมายความว่ารถทุกรุ่นจะดำเนินการได้ ยานพาหนะจะแสดงตามดัชนีในรายการ vehicles ของ ShipmentModel
costsPerVehicle[]

number

ระบุค่าใช้จ่ายที่เกิดขึ้นเมื่อนำส่งการจัดส่งนี้โดยยานพาหนะแต่ละคัน หากระบุไว้ จะต้องมีอย่างใดอย่างหนึ่งต่อไปนี้

  • มีจำนวนองค์ประกอบเท่ากับ costsPerVehicleIndices costsPerVehicle[i] สอดคล้องกับยานพาหนะ costsPerVehicleIndices[i] ของรุ่น
  • จำนวนองค์ประกอบเท่ากับจำนวนยานพาหนะในโมเดล องค์ประกอบที่ i สอดคล้องกับยานพาหนะ #i ของรุ่น

ค่าใช้จ่ายเหล่านี้ต้องเป็นหน่วยเดียวกับ penaltyCost และต้องไม่ติดลบ ปล่อยช่องนี้ว่างไว้หากไม่มีค่าใช้จ่ายดังกล่าว
costsPerVehicleIndices[]

integer

ดัชนีของยานพาหนะที่ costsPerVehicle มีผล หากไม่ใช่ค่าว่าง costsPerVehicle ต้องมีจำนวนองค์ประกอบเท่ากับ costsPerVehicle ระบุดัชนียานพาหนะได้ไม่เกิน 1 ครั้ง หากยานพาหนะไม่รวมอยู่ใน costsPerVehicleIndices ค่าของยานพาหนะจะเป็น 0
pickupToDeliveryAbsoluteDetourLimit

string (Duration format)

ระบุเวลาอ้อมสูงสุดสัมบูรณ์เทียบกับเส้นทางที่สั้นที่สุดตั้งแต่การไปรับจนถึงการนำส่ง หากระบุ ต้องไม่เป็นค่าลบ และการจัดส่งต้องมีการรับและการนำส่งอย่างน้อย 1 รายการ

ตัวอย่างเช่น สมมติให้ t เป็นเวลาที่สั้นที่สุดจากทางเลือกการรับสินค้าซึ่งเลือกไว้ไปยังทางเลือกการนำส่งซึ่งเลือกไว้โดยตรง จากนั้นการตั้งค่า pickupToDeliveryAbsoluteDetourLimit จะบังคับใช้สิ่งต่อไปนี้

startTime(delivery) - startTime(pickup) <=
t + pickupToDeliveryAbsoluteDetourLimit

หากระบุทั้งขีดจำกัดแบบสัมพัทธ์และแบบสัมบูรณ์ในการจัดส่งเดียวกัน ระบบจะใช้ขีดจำกัดที่จำกัดมากขึ้นสำหรับคู่การรับ/การนำส่งที่เป็นไปได้แต่ละคู่ ในเดือนตุลาคม 2017 ระบบรองรับการอ้อมเส้นทางเฉพาะในกรณีที่ระยะเวลาเดินทางไม่ขึ้นอยู่กับยานพาหนะ

ระยะเวลาเป็นวินาทีที่มีเศษทศนิยมได้สูงสุด 9 หลัก โดยลงท้ายด้วย "s" เช่น "3.5s"
pickupToDeliveryTimeLimit

string (Duration format)

ระบุระยะเวลาสูงสุดตั้งแต่เริ่มรับพัสดุไปจนถึงเริ่มนำส่งพัสดุ หากระบุ ต้องเป็นค่าบวก และการจัดส่งต้องมีการรับสินค้าและการนำส่งอย่างน้อย 1 รายการ ซึ่งไม่ได้ขึ้นอยู่กับว่าเลือกตัวเลือกใดสำหรับการรับและการนำส่ง หรือความเร็วของยานพาหนะ คุณสามารถระบุค่านี้ควบคู่ไปกับข้อจำกัดทางอ้อมสูงสุดได้ โดยโซลูชันจะยึดตามข้อกำหนดทั้ง 2 ข้อ

ระยะเวลาเป็นวินาทีที่มีเศษทศนิยมได้สูงสุด 9 หลัก โดยลงท้ายด้วย s เช่น "3.5s"
shipmentType

string

สตริงที่ไม่ใช่ค่าว่างซึ่งระบุ "ประเภท" สำหรับการจัดส่งนี้ ฟีเจอร์นี้ใช้เพื่อกำหนดความเข้ากันไม่ได้หรือข้อกำหนดระหว่าง shipment_types ได้ (ดู shipmentTypeIncompatibilities และ shipmentTypeRequirements ใน ShipmentModel)

แตกต่างจาก visitTypes ซึ่งระบุไว้สำหรับการเข้าชมครั้งเดียว: การรับ/การนำส่งทั้งหมดที่อยู่ในการจัดส่งเดียวกันจะมี shipmentType เดียวกัน
label

string

ระบุป้ายกำกับสำหรับการจัดส่งนี้ ระบบจะรายงานป้ายกำกับนี้ในการตอบกลับใน shipmentLabel ของ ShipmentRoute.Visit ที่เกี่ยวข้อง
ignore

boolean

หากเป็นจริง ให้ข้ามการจัดส่งนี้ แต่อย่าใช้ penaltyCost

การละเว้นการจัดส่งจะทำให้เกิดข้อผิดพลาดในการตรวจสอบเมื่อมี shipmentTypeRequirements ในโมเดล

ระบบอนุญาตให้ละเว้นการจัดส่งที่ดำเนินการใน injectedFirstSolutionRoutes หรือ injectedSolutionConstraint โปรแกรมโซลูชันจะนำการเรียกเข้ารับ/การนำส่งที่เกี่ยวข้องออกจากเส้นทางที่ดำเนินการ precedenceRules ที่จะอ้างอิงการจัดส่งที่ละเว้นก็จะไม่ได้รับการสนใจเช่นกัน
penaltyCost

number

หากการจัดส่งไม่เสร็จสมบูรณ์ ระบบจะเพิ่มค่าปรับนี้ลงในต้นทุนโดยรวมของเส้นทาง ระบบจะถือว่าการจัดส่งเสร็จสมบูรณ์หากมีการนำส่งหรือรับสินค้าตามทางเลือกใดทางเลือกหนึ่ง ค่าใช้จ่ายอาจแสดงเป็นหน่วยเดียวกับที่ใช้สำหรับช่องอื่นๆ ทั้งหมดที่เกี่ยวข้องกับต้นทุนในโมเดล และต้องมีค่าเป็นบวก

สำคัญ: หากไม่ได้ระบุค่าปรับนี้ ระบบจะถือว่าไม่มีขีดจำกัด ซึ่งหมายความว่าต้องจัดส่งให้เสร็จสมบูรณ์
pickupToDeliveryRelativeDetourLimit

number

ระบุเวลาอ้อมสูงสุดแบบสัมพัทธ์เทียบกับเส้นทางที่สั้นที่สุดตั้งแต่การไปรับจนถึงการนำส่ง หากระบุ ต้องไม่เป็นค่าลบ และการจัดส่งต้องมีการรับและการนำส่งอย่างน้อย 1 รายการ

ตัวอย่างเช่น สมมติให้ t เป็นเวลาที่สั้นที่สุดจากทางเลือกการรับสินค้าที่เลือกไปยังทางเลือกการนำส่งที่เลือกโดยตรง จากนั้นการตั้งค่า pickupToDeliveryRelativeDetourLimit จะบังคับใช้สิ่งต่อไปนี้

startTime(delivery) - startTime(pickup) <=
std::ceil(t * (1.0 + pickupToDeliveryRelativeDetourLimit))

หากระบุทั้งขีดจำกัดแบบสัมพัทธ์และแบบสัมบูรณ์ในการจัดส่งเดียวกัน ระบบจะใช้ขีดจำกัดที่จำกัดมากขึ้นสำหรับคู่การรับ/การนำส่งที่เป็นไปได้แต่ละคู่ ในเดือนตุลาคม 2017 ระบบรองรับการอ้อมเส้นทางเฉพาะในกรณีที่ระยะเวลาเดินทางไม่ขึ้นอยู่กับยานพาหนะ

VisitRequest

คำขอเข้าชมที่ยานพาหนะสามารถทำได้: ยานพาหนะมีตำแหน่งทางภูมิศาสตร์ (หรือ 2 ตำแหน่ง โปรดดูด้านล่าง) เวลาเปิดและปิดที่แสดงเป็นกรอบเวลา และระยะเวลาของบริการ (เวลาที่ยานพาหนะใช้ในการรับหรือส่งสินค้าเมื่อมาถึง)

การแสดง JSON 
{
  "arrivalLocation": {
    object (LatLng)
  },
  "arrivalWaypoint": {
    object (Waypoint)
  },
  "departureLocation": {
    object (LatLng)
  },
  "departureWaypoint": {
    object (Waypoint)
  },
  "tags": [
    string
  ],
  "timeWindows": [
    {
      object (TimeWindow)
    }
  ],
  "duration": string,
  "cost": number,
  "loadDemands": {
    string: {
      object (Load)
    },
    ...
  },
  "visitTypes": [
    string
  ],
  "label": string,
  "avoidUTurns": boolean
}
ช่อง
arrivalLocation

object (LatLng)

ตำแหน่งทางภูมิศาสตร์ที่ยานพาหนะมาถึงเมื่อทำ VisitRequest นี้ หากรูปแบบการจัดส่งมีเมตริกระยะทางตามระยะเวลา คุณไม่จำเป็นต้องระบุ arrivalLocation
arrivalWaypoint

object (Waypoint)

จุดสังเกตที่ยานพาหนะมาถึงเมื่อทำ VisitRequest นี้ หากรูปแบบการจัดส่งมีเมตริกระยะทางตามระยะเวลา จะต้องไม่ระบุ arrivalWaypoint
departureLocation

object (LatLng)

ตำแหน่งทางภูมิศาสตร์ที่ยานพาหนะออกเดินทางหลังจากทำ VisitRequest นี้เสร็จสิ้น ละเว้นได้หากเหมือนกับ arrivalLocation หากรูปแบบการจัดส่งมีเมตริกระยะทางตามระยะเวลา คุณต้องไม่ระบุ departureLocation
departureWaypoint

object (Waypoint)

จุดสังเกตที่ยานพาหนะออกเดินทางหลังจากทำ VisitRequest นี้เสร็จสมบูรณ์ ละเว้นได้หากค่านี้เหมือนกับ arrivalWaypoint หากรูปแบบการจัดส่งมีเมตริกระยะทางตามระยะเวลา จะต้องไม่ระบุ departureWaypoint
tags[]

string

ระบุแท็กที่แนบมากับคําขอเข้าชม ไม่อนุญาตให้ใช้สตริงที่ว่างเปล่าหรือซ้ำกัน
timeWindows[]

object (TimeWindow)

กรอบเวลาที่จํากัดเวลามาถึงในการเข้าชม โปรดทราบว่ายานพาหนะอาจออกเดินทางนอกกรอบเวลาการมาถึง เช่น เวลามาถึง + ระยะเวลาไม่จำเป็นต้องอยู่ภายในกรอบเวลา ซึ่งอาจส่งผลให้ต้องรอหากยานพาหนะมาถึงก่อน TimeWindow.start_time

หากไม่มี TimeWindow หมายความว่ายานพาหนะสามารถเข้าชมได้ทุกเมื่อ

กรอบเวลาต้องไม่ซ้อนทับกัน เช่น กรอบเวลาต้องไม่ซ้อนทับหรืออยู่ติดกับกรอบเวลาอื่น และต้องเป็นลำดับเวลาจากน้อยไปมาก

คุณจะตั้งค่า costPerHourAfterSoftEndTime และ softEndTime ได้ก็ต่อเมื่อมีกรอบเวลาเดียวเท่านั้น
duration

string (Duration format)

ระยะเวลาในการเข้าชม เช่น เวลาที่ใช้โดยยานพาหนะระหว่างที่มาถึงและออกเดินทาง (จะเพิ่มไปยังเวลารอที่เป็นไปได้ ดู timeWindows)

ระยะเวลาเป็นวินาทีที่มีเศษทศนิยมได้สูงสุด 9 หลัก โดยลงท้ายด้วย s เช่น "3.5s"
cost

number

ค่าบริการตามคำขอเข้าชมนี้ในเส้นทางของยานพาหนะ ซึ่งสามารถใช้ชำระค่าใช้จ่ายที่แตกต่างกันสำหรับการรับหรือการนำส่งพัสดุทางเลือกแต่ละรายการ ค่าใช้จ่ายนี้ต้องเป็นหน่วยเดียวกับ Shipment.penalty_cost และต้องไม่ติดลบ
loadDemands

map (key: string, value: object (Load))

โหลดดีมานด์ของคำขอเข้าชมนี้ ช่องนี้เหมือนกับช่อง Shipment.load_demands ยกเว้นว่าจะมีผลกับ VisitRequest นี้เท่านั้น ไม่ใช่ทั้ง Shipment ความต้องการที่ระบุไว้ที่นี่จะเพิ่มไปยังความต้องการที่ระบุไว้ใน Shipment.load_demands
visitTypes[]

string

ระบุประเภทการเข้าชม ข้อมูลนี้อาจใช้เพื่อจัดสรรเวลาเพิ่มเติมที่จําเป็นสําหรับยานพาหนะในการเข้าชมนี้ให้เสร็จสมบูรณ์ (ดู Vehicle.extra_visit_duration_for_visit_type)

ประเภทหนึ่งๆ จะปรากฏได้เพียงครั้งเดียว
label

string

ระบุป้ายกำกับสำหรับ VisitRequest นี้ ระบบจะรายงานป้ายกำกับนี้ในการตอบกลับเป็น visitLabel ใน ShipmentRoute.Visit ที่เกี่ยวข้อง
avoidUTurns

boolean

ระบุว่าควรหลีกเลี่ยงการยูเทิร์นในเส้นทางขับรถ ณ ตำแหน่งนี้หรือไม่ ระบบจะพยายามเลี่ยงการเลี้ยวกลับอย่างสุดความสามารถ แต่ไม่สามารถรับประกันได้ว่าจะเลี่ยงได้ทั้งหมด นี่เป็นฟีเจอร์ทดลองและลักษณะการทำงานอาจมีการเปลี่ยนแปลง

เวอร์ชันทดลอง: ดูรายละเอียดเพิ่มเติมได้ที่ https://developers.google.com/maps/tt/route-optimization/experimental/u-turn-avoidance/make-request

LatLng

ออบเจ็กต์ที่แสดงคู่ละติจูด/ลองจิจูด ซึ่งแสดงเป็นคู่ของตัวเลขทศนิยมเพื่อแสดงองศาละติจูดและองศาลองจิจูด วัตถุนี้ต้องเป็นไปตาม มาตรฐาน WGS84 เว้นแต่จะระบุไว้เป็นอย่างอื่น ค่าต้องอยู่ในช่วงที่ได้รับการทำให้เป็นมาตรฐาน

การแสดง JSON 
{
  "latitude": number,
  "longitude": number
}
ช่อง
latitude

number

ละติจูดเป็นองศา โดยต้องอยู่ในช่วง [-90.0, +90.0]
longitude

number

ลองจิจูดเป็นองศา โดยต้องอยู่ในช่วง [-180.0, +180.0]

จุดบอกทาง

บรรจุข้อมูลจุดอ้างอิง จุดสังเกตจะระบุตำแหน่งมาถึงและออกเดินทางของคำขอเข้าชม รวมถึงตำแหน่งเริ่มต้นและสิ้นสุดของยานพาหนะ

การแสดง JSON 
{
  "sideOfRoad": boolean,
  "vehicleStopover": boolean,

  // Union field location_type can be only one of the following:
  "location": {
    object (Location)
  },
  "placeId": string
  // End of list of possible types for union field location_type.
}
ช่อง
sideOfRoad

boolean

ไม่บังคับ บ่งบอกว่าตําแหน่งของจุดแวะพักนี้มีไว้เพื่อกำหนดค่ากําหนดให้ยานพาหนะหยุดที่ด้านใดด้านหนึ่งของถนน เมื่อคุณตั้งค่านี้ เส้นทางจะผ่านสถานที่ตั้งเพื่อให้ยานพาหนะหยุดที่ด้านข้างถนนซึ่งอยู่ถัดจากจุดศูนย์กลางของถนน ตัวเลือกนี้ใช้ไม่ได้กับโหมดการเดินทาง "เดิน"
vehicleStopover

boolean

บ่งบอกว่าจุดกึ่งกลางมีไว้สำหรับให้ยานพาหนะหยุดเพื่อรับหรือส่งผู้โดยสาร ตัวเลือกนี้ใช้ได้กับโหมดการเดินทาง "ขับรถ" เท่านั้น และเมื่อมี "locationType" เป็น "location"

ทดลอง: ลักษณะการทำงานหรือการมีอยู่ของช่องนี้อาจมีการเปลี่ยนแปลงในอนาคต
ฟิลด์สหภาพ location_type วิธีต่างๆ ในการแสดงสถานที่ location_type ต้องเป็นค่าใดค่าหนึ่งต่อไปนี้เท่านั้น
location

object (Location)

จุดที่ระบุโดยใช้พิกัดทางภูมิศาสตร์ รวมถึงส่วนหัวที่ไม่บังคับ
placeId

string

รหัสสถานที่จุดที่น่าสนใจที่เชื่อมโยงกับจุดสังเกต

เมื่อใช้รหัสสถานที่เพื่อระบุสถานที่ถึงหรือออกเดินทางของคำขอเข้าชม ให้ใช้รหัสสถานที่ที่เฉพาะเจาะจงเพียงพอที่จะระบุตำแหน่ง LatLng สำหรับการไปยังสถานที่นั้น เช่น รหัสสถานที่ที่แสดงถึงอาคารเหมาะที่จะใช้ แต่เราไม่แนะนำให้ใช้รหัสสถานที่ที่แสดงถึงถนน

ตำแหน่ง

บรรจุสถานที่ตั้ง (จุดทางภูมิศาสตร์และส่วนหัวที่ไม่บังคับ)

การแสดง JSON 
{
  "latLng": {
    object (LatLng)
  },
  "heading": integer
}
ช่อง
latLng

object (LatLng)

พิกัดทางภูมิศาสตร์ของจุดสังเกต
heading

integer

เข็มทิศที่เชื่อมโยงกับทิศทางของการเข้าชม ค่านี้ใช้เพื่อระบุฝั่งถนนที่จะใช้รับและส่งผู้โดยสาร ค่าทิศทางมีตั้งแต่ 0 ถึง 360 โดยที่ 0 ระบุทิศทางเป็นทิศเหนือ 90 ระบุทิศทางเป็นทิศตะวันออก เป็นต้น

TimeWindow

กรอบเวลาจะจำกัดเวลาของเหตุการณ์ เช่น เวลามาถึงที่จุดแวะพัก หรือเวลาเริ่มต้นและสิ้นสุดของยานพาหนะ

ขอบเขตกรอบเวลาแบบบังคับ startTime และ endTime จะบังคับใช้เวลาเริ่มต้นเร็วที่สุดและช้าสุดของเหตุการณ์ เช่น startTime <= event_time <= endTime ขอบเขตล่างของกรอบเวลาแบบยืดหยุ่น softStartTime แสดงถึงค่ากําหนดให้เหตุการณ์เกิดขึ้นตั้งแต่หรือหลังจาก softStartTime โดยจะมีค่าใช้จ่ายตามสัดส่วนกับระยะเวลาก่อนที่เหตุการณ์จะเกิดขึ้นก่อน softStartTime ขอบบนของกรอบเวลาแบบยืดหยุ่น softEndTime แสดงถึงค่ากําหนดให้เหตุการณ์เกิดขึ้นในหรือก่อนวันที่ softEndTime โดยจะมีต้นทุนตามสัดส่วนกับระยะเวลาหลังจากที่เกิดเหตุการณ์หลังจากวันที่ softEndTime startTime, endTime, softStartTime และ softEndTime ควรอยู่ภายในขีดจำกัดเวลาทั่วโลก (ดู ShipmentModel.global_start_time และ ShipmentModel.global_end_time) และควรเป็นไปตามข้อกำหนดต่อไปนี้

  0 <= `startTime` <= `endTime` and
  0 <= `startTime` <= `softStartTime` and
  0 <= `softEndTime` <= `endTime`.
การแสดง JSON 
{
  "startTime": string,
  "endTime": string,
  "softStartTime": string,
  "softEndTime": string,
  "costPerHourBeforeSoftStartTime": number,
  "costPerHourAfterSoftEndTime": number
}
ช่อง
startTime

string (Timestamp format)

เวลาเริ่มต้นของกรอบเวลาที่เจาะจง หากไม่ระบุ ระบบจะตั้งค่าเป็น ShipmentModel.global_start_time

ใช้ RFC 3339 ซึ่งเอาต์พุตที่สร้างขึ้นจะเป็นรูปแบบ Z-normalized เสมอ และใช้ตัวเลขทศนิยม 0, 3, 6 หรือ 9 ระบบยังยอมรับออฟเซตอื่นๆ นอกเหนือจาก "Z" ด้วย ตัวอย่างเช่น "2014-10-02T15:01:23Z", "2014-10-02T15:01:23.045123456Z" หรือ "2014-10-02T15:01:23+05:30"
endTime

string (Timestamp format)

เวลาสิ้นสุดของกรอบเวลา หากไม่ระบุ ระบบจะตั้งค่าเป็น ShipmentModel.global_end_time

ใช้ RFC 3339 ซึ่งเอาต์พุตที่สร้างขึ้นจะเป็นรูปแบบ Z-normalized เสมอ และใช้ตัวเลขทศนิยม 0, 3, 6 หรือ 9 ระบบยังยอมรับออฟเซตอื่นๆ นอกเหนือจาก "Z" ด้วย ตัวอย่างเช่น "2014-10-02T15:01:23Z", "2014-10-02T15:01:23.045123456Z" หรือ "2014-10-02T15:01:23+05:30"
softStartTime

string (Timestamp format)

เวลาเริ่มต้นแบบค่อยเป็นค่อยไปของกรอบเวลา

ใช้ RFC 3339 ซึ่งเอาต์พุตที่สร้างขึ้นจะเป็นรูปแบบ Z-normalized เสมอ และใช้ตัวเลขทศนิยม 0, 3, 6 หรือ 9 ระบบยังยอมรับออฟเซตอื่นๆ นอกเหนือจาก "Z" ด้วย ตัวอย่างเช่น "2014-10-02T15:01:23Z", "2014-10-02T15:01:23.045123456Z" หรือ "2014-10-02T15:01:23+05:30"
softEndTime

string (Timestamp format)

เวลาสิ้นสุดโดยประมาณของกรอบเวลา

ใช้ RFC 3339 ซึ่งเอาต์พุตที่สร้างขึ้นจะเป็นรูปแบบ Z-normalized เสมอ และใช้ตัวเลขทศนิยม 0, 3, 6 หรือ 9 ระบบยังยอมรับออฟเซตอื่นๆ นอกเหนือจาก "Z" ด้วย ตัวอย่างเช่น "2014-10-02T15:01:23Z", "2014-10-02T15:01:23.045123456Z" หรือ "2014-10-02T15:01:23+05:30"
costPerHourBeforeSoftStartTime

number

ค่าใช้จ่ายต่อชั่วโมงที่เพิ่มจากค่าใช้จ่ายอื่นๆ ในโมเดล หากเหตุการณ์เกิดขึ้นก่อน softStartTime โดยคำนวณดังนี้

   max(0, softStartTime - t.seconds)
                          * costPerHourBeforeSoftStartTime / 3600,
t being the time of the event.

ต้นทุนนี้ต้องเป็นค่าบวก และคุณจะตั้งค่าช่องนี้ได้ก็ต่อเมื่อตั้งค่า softStartTime แล้วเท่านั้น
costPerHourAfterSoftEndTime

number

ค่าใช้จ่ายต่อชั่วโมงที่เพิ่มลงในค่าใช้จ่ายอื่นๆ ในโมเดลหากเหตุการณ์เกิดขึ้นหลังจาก softEndTime โดยคํานวณดังนี้

   max(0, t.seconds - softEndTime.seconds)
                    * costPerHourAfterSoftEndTime / 3600,
t being the time of the event.

ต้นทุนนี้ต้องเป็นค่าบวก และคุณจะตั้งค่าช่องนี้ได้ก็ต่อเมื่อตั้งค่า softEndTime แล้วเท่านั้น

ยานพาหนะ

จำลองยานพาหนะที่มีปัญหาการจัดส่ง การแก้ปัญหาการจัดส่งจะสร้างเส้นทางที่เริ่มต้นจาก startLocation และสิ้นสุดที่ endLocation สำหรับยานพาหนะนี้ เส้นทางคือลําดับการเข้าชม (ดู ShipmentRoute)

การแสดง JSON 
{
  "displayName": string,
  "travelMode": enum (TravelMode),
  "routeModifiers": {
    object (RouteModifiers)
  },
  "startLocation": {
    object (LatLng)
  },
  "startWaypoint": {
    object (Waypoint)
  },
  "endLocation": {
    object (LatLng)
  },
  "endWaypoint": {
    object (Waypoint)
  },
  "startTags": [
    string
  ],
  "endTags": [
    string
  ],
  "startTimeWindows": [
    {
      object (TimeWindow)
    }
  ],
  "endTimeWindows": [
    {
      object (TimeWindow)
    }
  ],
  "unloadingPolicy": enum (UnloadingPolicy),
  "loadLimits": {
    string: {
      object (LoadLimit)
    },
    ...
  },
  "costPerHour": number,
  "costPerTraveledHour": number,
  "costPerKilometer": number,
  "fixedCost": number,
  "usedIfRouteIsEmpty": boolean,
  "routeDurationLimit": {
    object (DurationLimit)
  },
  "travelDurationLimit": {
    object (DurationLimit)
  },
  "routeDistanceLimit": {
    object (DistanceLimit)
  },
  "extraVisitDurationForVisitType": {
    string: string,
    ...
  },
  "breakRule": {
    object (BreakRule)
  },
  "label": string,
  "ignore": boolean,
  "travelDurationMultiple": number
}
ช่อง
displayName

string

ชื่อที่แสดงของยานพาหนะที่ผู้ใช้กำหนด โดยชื่อมีความยาวได้สูงสุด 63 อักขระ และใช้อักขระ UTF-8 ได้
travelMode

enum (TravelMode)

โหมดการเดินทางที่ส่งผลต่อถนนที่ยานพาหนะใช้ได้และความเร็วของยานพาหนะ ดู travelDurationMultiple เพิ่มเติม
routeModifiers

object (RouteModifiers)

ชุดเงื่อนไขที่ต้องเป็นไปตามที่ส่งผลต่อวิธีคำนวณเส้นทางสำหรับยานพาหนะหนึ่งๆ
startLocation

object (LatLng)

สถานที่ตั้งทางภูมิศาสตร์ที่ยานพาหนะเริ่มต้นก่อนไปรับการจัดส่ง หากไม่ได้ระบุ ยานพาหนะจะเริ่มที่จุดรับส่งแรก หากรูปแบบการจัดส่งมีเมทริกซ์ระยะเวลาและระยะทาง คุณไม่จำเป็นต้องระบุ startLocation
startWaypoint

object (Waypoint)

จุดสังเกตที่แสดงสถานที่ตั้งทางภูมิศาสตร์ที่ยานพาหนะเริ่มต้นก่อนรับการจัดส่ง หากไม่ได้ระบุ startWaypoint หรือ startLocation ยานพาหนะจะเริ่มที่จุดรับส่งแรก หากรูปแบบการจัดส่งมีเมทริกซ์ระยะเวลาและระยะทาง คุณไม่จำเป็นต้องระบุ startWaypoint
endLocation

object (LatLng)

สถานที่ตั้งทางภูมิศาสตร์ที่ยานพาหนะสิ้นสุดการเดินทางหลังจาก VisitRequest สุดท้าย หากไม่ระบุ ShipmentRoute ของยานพาหนะจะสิ้นสุดทันทีเมื่อ VisitRequest สุดท้ายเสร็จสมบูรณ์ หากรูปแบบการจัดส่งมีเมทริกซ์ระยะเวลาและระยะทาง คุณไม่จำเป็นต้องระบุ endLocation
endWaypoint

object (Waypoint)

จุดสังเกตที่แสดงสถานที่ตั้งทางภูมิศาสตร์ที่ยานพาหนะสิ้นสุดการเดินทางหลังจากทำ VisitRequest รายการสุดท้าย หากไม่ได้ระบุทั้ง endWaypoint และ endLocation ShipmentRoute ของยานพาหนะจะสิ้นสุดทันทีเมื่อ VisitRequest สุดท้ายเสร็จสมบูรณ์ หากรูปแบบการจัดส่งมีเมทริกซ์ระยะเวลาและระยะทาง คุณไม่จำเป็นต้องระบุ endWaypoint
startTags[]

string

ระบุแท็กที่แนบมากับจุดเริ่มต้นของเส้นทางของยานพาหนะ

ไม่อนุญาตให้ใช้สตริงที่ว่างเปล่าหรือซ้ำกัน
endTags[]

string

ระบุแท็กที่แนบมากับส่วนท้ายของเส้นทางของยานพาหนะ

ไม่อนุญาตให้ใช้สตริงที่ว่างเปล่าหรือซ้ำกัน
startTimeWindows[]

object (TimeWindow)

ช่วงเวลาที่ยานพาหนะอาจออกจากจุดเริ่มต้น โดยต้องอยู่ภายในขีดจำกัดเวลาส่วนกลาง (ดูช่อง ShipmentModel.global_*) หากไม่ได้ระบุไว้ ระบบจะไม่จำกัดเวลานอกเหนือจากขีดจำกัดเวลาทั่วโลกเหล่านั้น

กรอบเวลาของช่องที่เกิดซ้ำเดียวกันต้องไม่ซ้อนทับกัน เช่น กรอบเวลาต้องไม่ซ้อนทับหรืออยู่ติดกับกรอบเวลาอื่น และต้องเป็นลำดับตามลำดับเวลา

คุณจะตั้งค่า costPerHourAfterSoftEndTime และ softEndTime ได้ก็ต่อเมื่อมีกรอบเวลาเดียวเท่านั้น
endTimeWindows[]

object (TimeWindow)

กรอบเวลายานพาหนะอาจมาถึงจุดหมาย โดยต้องอยู่ภายในขีดจำกัดเวลาส่วนกลาง (ดูช่อง ShipmentModel.global_*) หากไม่ได้ระบุไว้ ระบบจะไม่จำกัดเวลานอกเหนือจากขีดจำกัดเวลาทั่วโลกเหล่านั้น

กรอบเวลาของช่องที่เกิดซ้ำเดียวกันต้องไม่ซ้อนทับกัน เช่น กรอบเวลาต้องไม่ซ้อนทับหรืออยู่ติดกับกรอบเวลาอื่น และต้องเป็นลำดับตามลำดับเวลา

คุณจะตั้งค่า costPerHourAfterSoftEndTime และ softEndTime ได้ก็ต่อเมื่อมีกรอบเวลาเดียวเท่านั้น
unloadingPolicy

enum (UnloadingPolicy)

นโยบายการขนถ่ายที่บังคับใช้กับยานพาหนะ
loadLimits

map (key: string, value: object (LoadLimit))

ความจุของยานพาหนะ (น้ำหนัก ปริมาณ จำนวนพาเลต เป็นต้น) คีย์ในแผนที่คือตัวระบุประเภทของการโหลด ซึ่งสอดคล้องกับคีย์ของฟิลด์ Shipment.load_demands หากไม่มีคีย์ใดในแผนที่นี้ ระบบจะถือว่าความจุที่เกี่ยวข้องนั้นไม่มีขีดจำกัด
costPerHour

number

ค่ายานพาหนะ: ค่าใช้จ่ายทั้งหมดจะรวมกันและต้องเป็นหน่วยเดียวกับ Shipment.penalty_cost

ค่าบริการต่อชั่วโมงของเส้นทางยานพาหนะ ค่าใช้จ่ายนี้จะมีผลกับเวลาทั้งหมดที่ใช้ในเส้นทาง ซึ่งรวมถึงเวลาเดินทาง เวลารอ และเวลาเข้าชม การใช้ costPerHour แทน costPerTraveledHour เพียงอย่างเดียวอาจทำให้เกิดความล่าช้าเพิ่มเติม
costPerTraveledHour

number

ค่าบริการต่อชั่วโมงที่เดินทางของเส้นทางยานพาหนะ ต้นทุนนี้มีผลกับเวลาเดินทางตามเส้นทางเท่านั้น (นั่นคือเวลาที่รายงานใน ShipmentRoute.transitions) และไม่รวมเวลารอและเวลาเข้าชม
costPerKilometer

number

ค่าบริการต่อกิโลเมตรของเส้นทางยานพาหนะ โดยค่าใช้จ่ายนี้จะมีผลกับระยะทางที่รายงานใน ShipmentRoute.transitions และไม่มีผลกับระยะทางที่เดินทางโดยนัยจาก arrivalLocation ไปยัง departureLocation ของ VisitRequest รายการเดียว
fixedCost

number

ค่าใช้จ่ายคงที่จะมีผลหากใช้ยานพาหนะนี้เพื่อจัดการการจัดส่ง
usedIfRouteIsEmpty

boolean

ช่องนี้จะใช้ได้กับยานพาหนะเมื่อเส้นทางของยานพาหนะนั้นไม่มีการจัดส่ง ข้อมูลนี้ระบุว่าควรถือว่ายานพาหนะเป็นยานพาหนะมือสองหรือไม่ในกรณีนี้

หากเป็น "จริง" ยานพาหนะจะเดินทางจากจุดเริ่มต้นไปยังจุดสิ้นสุดแม้ว่าจะไม่มีการจัดส่งใดๆ เกิดขึ้น และระบบจะพิจารณาเวลาและค่าใช้จ่ายตามระยะทางที่เกิดจากการเดินทางจากจุดเริ่มต้นไปยังจุดสิ้นสุด

ไม่เช่นนั้น ยานพาหนะจะไม่เดินทางจากจุดเริ่มต้นไปยังจุดสิ้นสุด และไม่มีการกำหนดเวลา breakRule หรือความล่าช้า (จาก TransitionAttributes) สำหรับยานพาหนะนี้ ในกรณีนี้ ShipmentRoute ของยานพาหนะจะไม่มีข้อมูลใดๆ ยกเว้นดัชนีและป้ายกำกับยานพาหนะ
routeDurationLimit

object (DurationLimit)

ขีดจํากัดที่มีผลกับระยะเวลาทั้งหมดของเส้นทางยานพาหนะ ใน OptimizeToursResponse หนึ่งๆ ระยะเวลาของเส้นทางของยานพาหนะคือความแตกต่างระหว่าง vehicleEndTime กับ vehicleStartTime
travelDurationLimit

object (DurationLimit)

ขีดจํากัดที่มีผลกับระยะเวลาการเดินทางของเส้นทางยานพาหนะ ใน OptimizeToursResponse หนึ่งๆ ระยะเวลาการเดินทางของเส้นทางคือผลรวมของ transitions.travel_duration ทั้งหมด
routeDistanceLimit

object (DistanceLimit)

ขีดจํากัดมีผลกับระยะทางรวมของเส้นทางยานพาหนะ ใน OptimizeToursResponse หนึ่งๆ ระยะทางของเส้นทางคือผลรวมของ transitions.travel_distance_meters ทั้งหมด
extraVisitDurationForVisitType

map (key: string, value: string (Duration format))

ระบุการแมปจากสตริง visitTypes ไปยังระยะเวลา ระยะเวลาคือเวลาเพิ่มเติมจาก VisitRequest.duration ที่ใช้ในการเข้าชมที่มี visitTypes ที่ระบุ ระยะเวลาการเข้าชมเพิ่มเติมนี้จะเพิ่มค่าใช้จ่ายหากระบุ costPerHour คีย์ (เช่น visitTypes) ต้องไม่ใช่สตริงว่าง

หากคำขอเข้าชมมีหลายประเภท ระบบจะเพิ่มระยะเวลาสำหรับแต่ละประเภทในแผนที่
breakRule

object (BreakRule)

อธิบายกำหนดเวลาพักที่จะบังคับใช้กับยานพาหนะนี้ หากว่างเปล่า ระบบจะไม่กำหนดเวลาพักสำหรับยานพาหนะนี้
label

string

ระบุป้ายกำกับสำหรับยานพาหนะนี้ ระบบจะรายงานป้ายกำกับนี้ในการตอบกลับเป็น vehicleLabel ของ ShipmentRoute ที่เกี่ยวข้อง
ignore

boolean

หากเป็นจริง usedIfRouteIsEmpty ต้องเป็นเท็จ และยานพาหนะนี้จะยังคงไม่มีการใช้งาน

หากการจัดส่งดำเนินการโดยยานพาหนะที่ละเว้นใน injectedFirstSolutionRoutes ระบบจะข้ามการจัดส่งนั้นในโซลูชันแรก แต่สามารถดำเนินการในคำตอบได้

หากการจัดส่งดำเนินการโดยยานพาหนะที่ละเว้นใน injectedSolutionConstraint และมีการจำกัดการรับ/การนำส่งที่เกี่ยวข้องให้อยู่ในยานพาหนะ (กล่าวคือ ไม่ผ่อนปรนเป็นระดับ RELAX_ALL_AFTER_THRESHOLD) ระบบจะข้ามการจัดส่งนั้นในการตอบกลับ หากการจัดส่งมีช่อง allowedVehicleIndices ที่ไม่ว่างเปล่าและระบบละเว้นยานพาหนะที่อนุญาตทั้งหมด ระบบจะข้ามการจัดส่งนั้นในการตอบกลับ
travelDurationMultiple

number

ระบุตัวคูณที่สามารถใช้เพื่อเพิ่มหรือลดเวลาเดินทางของยานพาหนะนี้ เช่น การตั้งค่านี้เป็น 2.0 หมายความว่ายานพาหนะนี้ช้ากว่าและมีเวลาเดินทางเป็น 2 เท่าของยานพาหนะมาตรฐาน อัตราส่วนนี้ไม่ส่งผลต่อระยะเวลาในการเข้าชม แต่จะมีผลต่อต้นทุนหากมีการระบุ costPerHour หรือ costPerTraveledHour ค่านี้ต้องอยู่ในช่วง [0.001, 1000.0] หากไม่ได้ตั้งค่าไว้ ระบบจะถือว่ายานพาหนะเป็นแบบมาตรฐาน และตัวคูณนี้จะถือเป็น 1.0

โปรดทราบว่าระบบจะปัดเศษเวลาเดินทางเป็นวินาทีที่ใกล้ที่สุดหลังจากใช้ตัวคูณนี้ แต่ก่อนที่จะดำเนินการทางตัวเลขใดๆ ดังนั้นตัวคูณขนาดเล็กอาจทำให้ความแม่นยำลดลง

ดูข้อมูลเพิ่มเติมได้ที่ extraVisitDurationForVisitType ด้านล่าง

TravelMode

โหมดการเดินทางที่ยานพาหนะใช้ได้

ซึ่งควรเป็นชุดย่อยของโหมดการเดินทางของ Google Maps Platform Routes API ดูได้ที่ https://developers.google.com/maps/documentation/routes/reference/rest/v2/RouteTravelMode

หมายเหตุ: เส้นทาง WALKING อยู่ในรุ่นเบต้าและบางครั้งอาจไม่มีทางเท้าหรือทางเท้าที่ชัดเจน คุณต้องแสดงคำเตือนนี้ต่อผู้ใช้สำหรับเส้นทางเดินทั้งหมดที่คุณแสดงในแอป

Enum
TRAVEL_MODE_UNSPECIFIED โหมดการเดินทางที่ไม่ระบุ ซึ่งเทียบเท่ากับ DRIVING
DRIVING โหมดการเดินทางที่สอดคล้องกับเส้นทางการขับรถ (รถยนต์ ฯลฯ)
WALKING โหมดการเดินทางที่สอดคล้องกับเส้นทางเดิน

RouteModifiers

บรรจุชุดเงื่อนไขที่ไม่บังคับเพื่อใช้คำนวณเส้นทางของยานพาหนะ ซึ่งคล้ายกับ RouteModifiers ใน Routes Preferred API ของ Google Maps Platform โปรดดูที่ https://developers.google.com/maps/documentation/routes/reference/rest/v2/RouteModifiers

การแสดง JSON 
{
  "avoidTolls": boolean,
  "avoidHighways": boolean,
  "avoidFerries": boolean,
  "avoidIndoor": boolean
}
ช่อง
avoidTolls

boolean

ระบุว่าจะหลีกเลี่ยงถนนที่มีค่าผ่านทางหรือไม่ ระบบจะให้ความสำคัญกับเส้นทางที่ไม่มีถนนที่ต้องเสียค่าผ่านทาง ใช้ได้กับโหมดการเดินทางที่ใช้เครื่องยนต์เท่านั้น
avoidHighways

boolean

ระบุว่าจะเลี่ยงทางหลวงหรือไม่ ระบบจะให้ความสำคัญกับเส้นทางที่ไม่มีทางหลวง ใช้ได้กับโหมดการเดินทางที่ใช้เครื่องยนต์เท่านั้น
avoidFerries

boolean

ระบุว่าจะหลีกเลี่ยงเส้นทางเรือหรือไม่ ระบบจะให้ความสำคัญกับเส้นทางที่ไม่มีการเดินทางด้วยเรือข้ามฟาก ใช้ได้กับโหมดการเดินทางที่ใช้เครื่องยนต์เท่านั้น
avoidIndoor

boolean

ไม่บังคับ ระบุว่าจะหลีกเลี่ยงการนำทางภายในอาคารหรือไม่ ระบบจะให้ความสำคัญกับเส้นทางที่ไม่มีการนำทางในอาคาร ใช้กับโหมดการเดินทาง WALKING เท่านั้น

UnloadingPolicy

นโยบายเกี่ยวกับวิธีขนถ่ายยานพาหนะ ใช้กับการจัดส่งที่มีทั้งการรับสินค้าและการนำส่งเท่านั้น

การจัดส่งอื่นๆ จะเกิดขึ้นที่ใดก็ได้ในเส้นทางโดยไม่ขึ้นอยู่กับ unloadingPolicy

Enum
UNLOADING_POLICY_UNSPECIFIED นโยบายการขนถ่ายที่ไม่ได้ระบุไว้ การนำส่งต้องเกิดขึ้นหลังจากการไปรับสินค้าที่เกี่ยวข้อง
LAST_IN_FIRST_OUT การนำส่งต้องเกิดขึ้นในลำดับที่กลับกันจากการรับ
FIRST_IN_FIRST_OUT การนำส่งต้องเกิดขึ้นตามลำดับเดียวกับการรับสินค้า

LoadLimit

กําหนดขีดจํากัดน้ำหนักบรรทุกที่ใช้กับยานพาหนะ เช่น "รถบรรทุกนี้บรรทุกได้สูงสุด 3, 500 กก." ดูloadLimits

การแสดง JSON 
{
  "softMaxLoad": string,
  "costPerUnitAboveSoftMax": number,
  "startLoadInterval": {
    object (Interval)
  },
  "endLoadInterval": {
    object (Interval)
  },
  "maxLoad": string,
  "costPerKilometer": {
    object (LoadCost)
  },
  "costPerTraveledHour": {
    object (LoadCost)
  }
}
ช่อง
softMaxLoad

string (int64 format)

ขีดจำกัดแบบไม่เข้มงวดของการโหลด ดูcostPerUnitAboveSoftMax
costPerUnitAboveSoftMax

number

หากน้ำหนักบรรทุกเกิน softMaxLoad ตลอดเส้นทางของยานพาหนะนี้ ระบบจะใช้ค่าปรับค่าใช้จ่ายต่อไปนี้ (1 ครั้งต่อยานพาหนะ) (น้ำหนักบรรทุก - softMaxLoad) * costPerUnitAboveSoftMax ค่าใช้จ่ายทั้งหมดจะรวมกันและต้องเป็นหน่วยเดียวกับ Shipment.penalty_cost
startLoadInterval

object (Interval)

ระยะเวลาการบรรทุกที่ยอมรับได้ของยานพาหนะเมื่อเริ่มเส้นทาง
endLoadInterval

object (Interval)

ช่วงเวลาของการบรรทุกที่ยอมรับได้ของยานพาหนะเมื่อสิ้นสุดเส้นทาง
maxLoad

string (int64 format)

จำนวนการโหลดสูงสุดที่ยอมรับได้
costPerKilometer

object (LoadCost)

ค่าขนส่งน้ำหนัก 1 หน่วยในระยะทาง 1 กิโลเมตรสำหรับยานพาหนะนี้ ข้อมูลนี้สามารถใช้เป็นพร็อกซีสําหรับปริมาณการใช้เชื้อเพลิงได้ หากน้ำหนักบรรทุกคือน้ำหนัก (เป็นนิวตัน) น้ำหนักบรรทุก*กิโลเมตรจะมีมิติข้อมูลเป็นพลังงาน

เวอร์ชันทดลอง: ดูรายละเอียดเพิ่มเติมได้ที่ https://developers.google.com/maps/tt/route-optimization/experimental/load-cost/make-request
costPerTraveledHour

object (LoadCost)

ค่าใช้จ่ายในการเดินทางด้วยน้ำหนักบรรทุก 1 หน่วยเป็นเวลา 1 ชั่วโมงสำหรับยานพาหนะนี้

เวอร์ชันทดลอง: ดูรายละเอียดเพิ่มเติมได้ที่ https://developers.google.com/maps/tt/route-optimization/experimental/load-cost/make-request

ช่วงเวลา

ช่วงเวลาของปริมาณการโหลดที่ยอมรับได้

การแสดง JSON 
{
  "min": string,
  "max": string
}
ช่อง
min

string (int64 format)

น้ำหนักบรรทุกขั้นต่ำที่ยอมรับได้ ต้องมากกว่าหรือเท่ากับ 0 หากระบุทั้ง 2 รายการ min ต้อง ≤ max
max

string (int64 format)

น้ำหนักบรรทุกสูงสุดที่ยอมรับได้ ต้องมากกว่าหรือเท่ากับ 0 หากไม่ได้ระบุ ระบบจะไม่จำกัดการโหลดสูงสุดด้วยข้อความนี้ หากระบุทั้ง 2 รายการ min ต้อง ≤ max

LoadCost

ต้นทุนในการย้ายน้ำหนัก 1 หน่วยในช่วง Transition สำหรับโหลดหนึ่งๆ ค่าใช้จ่ายคือผลรวมของ 2 ส่วน ดังนี้

  • min(load, loadThreshold) * costPerUnitBelowThreshold
  • max(0, load - loadThreshold) * costPerUnitAboveThreshold

เมื่อใช้ต้นทุนนี้ โซลูชันจะเลือกแสดงโฆษณาตามดีมานด์สูงก่อน หรือจะเลือกแสดงดีมานด์สูงเป็นลำดับสุดท้ายก็ได้ เช่น หากยานพาหนะมี

load_limit {
  key: "weight"
  value {
    costPerKilometer {
      loadThreshold: 15
      costPerUnitBelowThreshold: 2.0
      costPerUnitAboveThreshold: 10.0
    }
  }
}

และเส้นทางคือ start,pickup,pickup,delivery,delivery,end โดยมีการเปลี่ยนผ่านดังนี้

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

ค่าใช้จ่ายที่เกิดขึ้นจาก LoadCost นี้คือ (cost_below * load_below * kilometers + cost_above * load_above * kms)

  • การเปลี่ยน 0: 0.0
  • การเปลี่ยน 1: 2.0 * 10 * 1.0 + 10.0 * 0 * 1.0 = 20.0
  • ช่วง 2: 2.0 * 15 * 1.0 + 10.0 * (20 - 15) * 1.0 = 80.0
  • การเปลี่ยน 3: 2.0 * 10 * 1.0 + 10.0 * 0 * 1.0 = 20.0
  • การเปลี่ยน 4: 0.0

ดังนั้น LoadCost ตลอดเส้นทางคือ 120.0

อย่างไรก็ตาม หากเส้นทางคือ start,pickup,delivery,pickup,delivery,end ที่มีการเปลี่ยนผ่าน ให้ทำดังนี้

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

ค่าใช้จ่ายที่เกิดขึ้นจาก LoadCost นี้จึงเท่ากับ

  • การเปลี่ยน 0: 0.0
  • การเปลี่ยน 1: 2.0 * 10 * 1.0 + 10.0 * 0 * 1.0 = 20.0
  • ทรานซิชัน 2: 0.0
  • การเปลี่ยน 3: 2.0 * 10 * 1.0 + 10.0 * 0 * 1.0 = 20.0
  • การเปลี่ยน 4: 0.0

LoadCost ตลอดเส้นทางคือ 40.0

LoadCost ทำให้โซลูชันที่มีทรานซิชันที่มีภาระมากมีราคาแพงขึ้น

เวอร์ชันทดลอง: ดูรายละเอียดเพิ่มเติมได้ที่ https://developers.google.com/maps/tt/route-optimization/experimental/load-cost/make-request

การแสดง JSON 
{
  "loadThreshold": string,
  "costPerUnitBelowThreshold": number,
  "costPerUnitAboveThreshold": number
}
ช่อง
loadThreshold

string (int64 format)

จำนวนโหลดที่มากกว่าต้นทุนในการย้ายโหลด 1 หน่วยจาก costPerUnitBelowThreshold เป็น costPerUnitAboveThreshold ต้องมากกว่าหรือเท่ากับ 0
costPerUnitBelowThreshold

number

ต้นทุนในการย้ายโหลด 1 หน่วยสําหรับแต่ละหน่วยระหว่าง 0 ถึงเกณฑ์ ต้องเป็นค่าที่แน่นอนและมากกว่าหรือเท่ากับ 0
costPerUnitAboveThreshold

number

ต้นทุนในการย้ายโหลด 1 หน่วยสําหรับแต่ละหน่วยที่เกินเกณฑ์ ในกรณีที่เกณฑ์กรณีพิเศษ = 0 จะเป็นต้นทุนคงที่ต่อหน่วย ต้องเป็นค่าที่แน่นอนและมากกว่าหรือเท่ากับ 0

DurationLimit

ขีดจํากัดที่กําหนดระยะเวลาสูงสุดของเส้นทางยานพาหนะ โดยอาจเป็นแบบแข็งหรือแบบนุ่มก็ได้

เมื่อกําหนดฟิลด์ขีดจํากัดสูงสุดแบบยืดหยุ่น จะต้องกําหนดทั้งเกณฑ์สูงสุดแบบยืดหยุ่นและต้นทุนที่เกี่ยวข้องร่วมกัน

การแสดง JSON 
{
  "maxDuration": string,
  "softMaxDuration": string,
  "quadraticSoftMaxDuration": string,
  "costPerHourAfterSoftMax": number,
  "costPerSquareHourAfterQuadraticSoftMax": number
}
ช่อง
maxDuration

string (Duration format)

ขีดจํากัดสูงสุดที่กําหนดให้ระยะเวลาไม่เกิน maxDuration

ระยะเวลาเป็นวินาทีที่มีเศษทศนิยมได้สูงสุด 9 หลัก โดยลงท้ายด้วย s เช่น "3.5s"
softMaxDuration

string (Duration format)

ขีดจํากัดแบบไม่บังคับซึ่งไม่ได้บังคับใช้ระยะเวลาสูงสุด แต่หากมีการละเมิด เส้นทางจะมีค่าใช้จ่าย ต้นทุนนี้จะรวมกับต้นทุนอื่นๆ ที่กําหนดไว้ในโมเดลซึ่งมีหน่วยเดียวกัน

หากมีการกําหนด softMaxDuration ต้องไม่เป็นค่าลบ หากมีการกําหนด maxDuration ด้วย softMaxDuration ต้องน้อยกว่า maxDuration

ระยะเวลาเป็นวินาทีที่มีเศษทศนิยมได้สูงสุด 9 หลัก โดยลงท้ายด้วย s เช่น "3.5s"
quadraticSoftMaxDuration

string (Duration format)

ขีดจํากัดแบบอ่อนจะไม่บังคับใช้ขีดจํากัดระยะเวลาสูงสุด แต่หากมีการละเมิด เส้นทางจะมีค่าใช้จ่ายตามระยะเวลาเป็น 2 เท่า ต้นทุนนี้จะรวมกับต้นทุนอื่นๆ ที่กําหนดไว้ในโมเดลซึ่งมีหน่วยเดียวกัน

หากมีการกําหนด quadraticSoftMaxDuration ต้องไม่เป็นค่าลบ หากมีการกําหนด maxDuration ด้วย quadraticSoftMaxDuration ต้องน้อยกว่า maxDuration และส่วนต่างต้องไม่เกิน 1 วัน

maxDuration - quadraticSoftMaxDuration <= 86400 seconds

ระยะเวลาเป็นวินาทีที่มีเศษทศนิยมได้สูงสุด 9 หลัก โดยลงท้ายด้วย s เช่น "3.5s"
costPerHourAfterSoftMax

number

ค่าใช้จ่ายต่อชั่วโมงที่เกิดขึ้นหากมีการละเมิดเกณฑ์ softMaxDuration ค่าใช้จ่ายเพิ่มเติมจะเป็น 0 หากระยะเวลาอยู่ต่ำกว่าเกณฑ์ มิเช่นนั้นค่าใช้จ่ายจะขึ้นอยู่กับระยะเวลา ดังนี้

  costPerHourAfterSoftMax * (duration - softMaxDuration)

ค่าใช้จ่ายต้องไม่ติดลบ
costPerSquareHourAfterQuadraticSoftMax

number

ต้นทุนต่อชั่วโมงสี่เหลี่ยมจัตุรัสที่เกิดขึ้นหากมีการละเมิดเกณฑ์ quadraticSoftMaxDuration

ค่าใช้จ่ายเพิ่มเติมจะเป็น 0 หากระยะเวลาอยู่ต่ำกว่าเกณฑ์ มิฉะนั้นค่าใช้จ่ายจะขึ้นอยู่กับระยะเวลา ดังนี้

  costPerSquareHourAfterQuadraticSoftMax *
  (duration - quadraticSoftMaxDuration)^2

ค่าใช้จ่ายต้องไม่ติดลบ

DistanceLimit

ขีดจำกัดที่กำหนดระยะทางสูงสุดที่เดินทางได้ โดยอาจเป็นแบบแข็งหรือแบบนุ่มก็ได้

หากกําหนดขีดจํากัดสูงสุดที่อนุญาตไว้ จะต้องกําหนดทั้ง softMaxMeters และ costPerKilometerAboveSoftMax และต้องไม่เป็นค่าลบ

การแสดง JSON 
{
  "maxMeters": string,
  "softMaxMeters": string,
  "costPerKilometerBelowSoftMax": number,
  "costPerKilometerAboveSoftMax": number
}
ช่อง
maxMeters

string (int64 format)

ขีดจํากัดสูงสุดที่กําหนดระยะทางไว้ไม่เกิน maxMeters ขีดจํากัดต้องไม่ติดลบ
softMaxMeters

string (int64 format)

ขีดจํากัดแบบไม่บังคับจะไม่บังคับใช้ขีดจํากัดระยะทางสูงสุด แต่หากมีการละเมิด ค่าใช้จ่ายจะเพิ่มขึ้นตามค่าใช้จ่ายอื่นๆ ที่กําหนดไว้ในรูปแบบเดียวกัน

หากมีการกําหนด softMaxMeters ต้องน้อยกว่า maxMeters และต้องไม่เป็นค่าติดลบ
costPerKilometerBelowSoftMax

number

ค่าใช้จ่ายต่อกิโลเมตรที่เกิดขึ้น ซึ่งเพิ่มขึ้นสูงสุด softMaxMeters โดยสูตรคำนวณดังนี้

  min(distanceMeters, softMaxMeters) / 1000.0 *
  costPerKilometerBelowSoftMax.

routeDistanceLimit ไม่รองรับค่าใช้จ่ายนี้
costPerKilometerAboveSoftMax

number

ค่าใช้จ่ายต่อกิโลเมตรที่เกิดขึ้นหากระยะทางเกินขีดจำกัด softMaxMeters ค่าใช้จ่ายเพิ่มเติมจะเป็น 0 หากระยะทางต่ำกว่าขีดจำกัด มิเช่นนั้นสูตรที่ใช้คำนวณค่าใช้จ่ายจะเป็นดังนี้

  (distanceMeters - softMaxMeters) / 1000.0 *
  costPerKilometerAboveSoftMax.

ค่าใช้จ่ายต้องไม่ติดลบ

BreakRule

กฎในการสร้างช่วงพักสำหรับยานพาหนะ (เช่น ช่วงพักเที่ยง) ช่วงพักคือช่วงเวลาต่อเนื่องที่ยานพาหนะไม่ได้ทำงานอยู่ที่ตําแหน่งปัจจุบันและไม่สามารถเข้าชมได้ ช่วงพักอาจเกิดขึ้นในกรณีต่อไปนี้

  • ระหว่างการเดินทางระหว่างการเข้าชม 2 ครั้ง (ซึ่งรวมถึงเวลาก่อนหรือหลังการเข้าชม แต่ไม่ใช่ระหว่างการเข้าชม) ในกรณีนี้ ระบบจะขยายเวลาเดินทางที่เกี่ยวข้องระหว่างการเข้าชม
  • หรือก่อนที่รถจะสตาร์ท (รถอาจไม่สตาร์ทในช่วงพัก) ในกรณีนี้จะไม่ส่งผลต่อเวลาสตาร์ทรถ
  • หรือหลังจากสิ้นสุดการให้บริการของยานพาหนะ (เช่นเดียวกับเวลาสิ้นสุดการให้บริการของยานพาหนะ)
การแสดง JSON 
{
  "breakRequests": [
    {
      object (BreakRequest)
    }
  ],
  "frequencyConstraints": [
    {
      object (FrequencyConstraint)
    }
  ]
}
ช่อง
breakRequests[]

object (BreakRequest)

ลำดับของช่วงพัก ดูข้อความ BreakRequest
frequencyConstraints[]

object (FrequencyConstraint)

อาจมี FrequencyConstraint หลายรายการ รายการทั้งหมดต้องเป็นไปตามBreakRequestของBreakRuleนี้ ดูที่ FrequencyConstraint

BreakRequest

คุณต้องทราบลำดับของช่วงพัก (เช่น จำนวนและลำดับ) ที่มีผลกับยานพาหนะแต่ละคันล่วงหน้า BreakRequest ที่ซ้ำกันจะกำหนดลำดับนั้นตามลำดับที่ต้องทำ กรอบเวลา (earliestStartTime / latestStartTime) อาจทับซ้อนกัน แต่ต้องเข้ากันได้กับคำสั่งซื้อ (ระบบจะตรวจสอบ)

การแสดง JSON 
{
  "earliestStartTime": string,
  "latestStartTime": string,
  "minDuration": string
}
ช่อง
earliestStartTime

string (Timestamp format)

ต้องระบุ ขอบเขตล่าง (รวม) ของช่วงพัก

ใช้ RFC 3339 ซึ่งเอาต์พุตที่สร้างขึ้นจะเป็นรูปแบบ Z-normalized เสมอ และใช้ตัวเลขทศนิยม 0, 3, 6 หรือ 9 ระบบยังยอมรับออฟเซตอื่นๆ นอกเหนือจาก "Z" ด้วย ตัวอย่างเช่น "2014-10-02T15:01:23Z", "2014-10-02T15:01:23.045123456Z" หรือ "2014-10-02T15:01:23+05:30"
latestStartTime

string (Timestamp format)

ต้องระบุ ขอบเขตบน (รวม) ของจุดเริ่มต้นของช่วงพัก

ใช้ RFC 3339 ซึ่งเอาต์พุตที่สร้างขึ้นจะเป็นรูปแบบ Z-normalized เสมอ และใช้ตัวเลขทศนิยม 0, 3, 6 หรือ 9 ระบบยังยอมรับออฟเซตอื่นๆ นอกเหนือจาก "Z" ด้วย ตัวอย่างเช่น "2014-10-02T15:01:23Z", "2014-10-02T15:01:23.045123456Z" หรือ "2014-10-02T15:01:23+05:30"
minDuration

string (Duration format)

ต้องระบุ ระยะเวลาขั้นต่ำของช่วงพัก ต้องเป็นค่าบวก

ระยะเวลาเป็นวินาทีที่มีเศษทศนิยมได้สูงสุด 9 หลัก โดยลงท้ายด้วย s เช่น "3.5s"

FrequencyConstraint

คุณสามารถจำกัดความถี่และระยะเวลาของช่วงพักที่ระบุไว้ข้างต้นเพิ่มเติมได้โดยการบังคับใช้ความถี่ของช่วงพักขั้นต่ำ เช่น "ต้องมีช่วงพักอย่างน้อย 1 ชั่วโมงทุก 12 ชั่วโมง" สมมติว่าสามารถตีความได้ว่า "ภายในกรอบเวลาแบบเลื่อนได้ 12 ชั่วโมง ต้องมีช่วงพักอย่างน้อย 1 ชั่วโมงอย่างน้อย 1 ช่วง" ตัวอย่างดังกล่าวจะแปลเป็น FrequencyConstraint ดังนี้

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

ช่วงเวลาและระยะเวลาของช่วงพักในโซลูชันจะเป็นไปตามข้อจำกัดดังกล่าวทั้งหมด นอกเหนือจากกรอบเวลาและระยะเวลาขั้นต่ำที่ระบุไว้ใน BreakRequest แล้ว

ในทางปฏิบัติ FrequencyConstraint อาจใช้กับช่วงพักที่ไม่ต่อเนื่อง ตัวอย่างเช่น กำหนดการต่อไปนี้เป็นไปตามตัวอย่าง "1 ชั่วโมงทุก 12 ชั่วโมง"

  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
การแสดง JSON 
{
  "minBreakDuration": string,
  "maxInterBreakDuration": string
}
ช่อง
minBreakDuration

string (Duration format)

ต้องระบุ ระยะเวลาขั้นต่ำของช่วงพักสำหรับข้อจำกัดนี้ มีค่าไม่ติดลบ ดูคำอธิบายของ FrequencyConstraint

ระยะเวลาเป็นวินาทีที่มีเศษทศนิยมได้สูงสุด 9 หลัก โดยลงท้ายด้วย s เช่น "3.5s"
maxInterBreakDuration

string (Duration format)

ต้องระบุ ช่วงเวลาสูงสุดที่อนุญาตในเส้นทางซึ่งไม่มีช่วงพัก duration >= minBreakDuration อย่างน้อยบางส่วน ต้องเป็นค่าบวก

ระยะเวลาเป็นวินาทีที่มีเศษทศนิยมได้สูงสุด 9 หลัก โดยลงท้ายด้วย s เช่น "3.5s"

วัตถุประสงค์

วัตถุประสงค์จะแทนที่รูปแบบต้นทุนโดยสมบูรณ์ จึงใช้ร่วมกับต้นทุนที่มีอยู่ไม่ได้ วัตถุประสงค์แต่ละรายการจะเชื่อมโยงกับค่าใช้จ่ายที่กำหนดไว้ล่วงหน้าจำนวนหนึ่ง เช่น แอตทริบิวต์ยานพาหนะ การจัดส่ง หรือการเปลี่ยน

เวอร์ชันทดลอง: ดูรายละเอียดเพิ่มเติมได้ที่ https://developers.google.com/maps/tt/route-optimization/experimental/objectives/make-request

การแสดง JSON 
{
  "type": enum (Type),
  "weight": number
}
ช่อง
type

enum (Type)

ประเภทของวัตถุประสงค์
weight

number

ความสําคัญของวัตถุประสงค์นี้เมื่อเทียบกับวัตถุประสงค์อื่นๆ ซึ่งอาจเป็นจำนวนใดก็ได้ที่ไม่ใช่ค่าลบ โดยน้ำหนักไม่จำเป็นต้องรวมกันได้เท่ากับ 1 น้ำหนักเริ่มต้นคือ 1.0

ประเภท

ประเภทวัตถุประสงค์ที่จะแมปกับชุดค่าใช้จ่าย

Enum
DEFAULT ระบบจะใช้ชุดค่าใช้จ่ายเริ่มต้นเพื่อให้ได้โซลูชันที่สมเหตุสมผล หมายเหตุ: วัตถุประสงค์นี้สามารถใช้เพียงอย่างเดียวได้ แต่ระบบจะเพิ่มวัตถุประสงค์นี้ด้วยน้ำหนัก 1.0 เสมอเป็นพื้นฐานให้กับวัตถุประสงค์ที่ผู้ใช้ระบุไว้ หากยังไม่มีวัตถุประสงค์ดังกล่าว
MIN_DISTANCE วัตถุประสงค์ "MIN" ระยะทางรวมในการเดินทางน้อยที่สุด
MIN_WORKING_TIME ลดเวลาทํางานทั้งหมดโดยรวมของยานพาหนะทั้งหมด
MIN_TRAVEL_TIME เหมือนกับด้านบน แต่เน้นที่เวลาเดินทางเท่านั้น
MIN_NUM_VEHICLES ลดจำนวนยานพาหนะที่ใช้งาน

DurationDistanceMatrix

ระบุระยะเวลาและเมตริกระยะทางจากสถานที่เริ่มต้นของยานพาหนะและการเข้าชมไปยังสถานที่สิ้นสุดของยานพาหนะและการเข้าชม

การแสดง JSON 
{
  "rows": [
    {
      object (Row)
    }
  ],
  "vehicleStartTag": string
}
ช่อง
rows[]

object (Row)

ระบุแถวของเมทริกซ์ระยะเวลาและระยะทาง โดยต้องมีองค์ประกอบเท่ากับ ShipmentModel.duration_distance_matrix_src_tags
vehicleStartTag

string

แท็กที่กําหนดว่าเมตริกระยะเวลาและระยะทางนี้มีผลกับยานพาหนะใด หากเป็นค่าว่าง รายการนี้จะมีผลกับยานพาหนะทุกคัน และจะมีได้เพียงเมทริกซ์เดียวเท่านั้น

การเริ่มต้นยานพาหนะแต่ละรายการต้องตรงกับเมทริกซ์เพียงรายการเดียว กล่าวคือ ช่อง startTags รายการใดรายการหนึ่งต้องตรงกับ vehicleStartTag ของเมทริกซ์ (และของเมทริกซ์นั้นเท่านั้น)

เมทริกซ์ทั้งหมดต้องมี vehicleStartTag ไม่ซ้ำกัน

แถว

ระบุแถวของเมทริกซ์ระยะเวลาและระยะทาง

การแสดง JSON 
{
  "durations": [
    string
  ],
  "meters": [
    number
  ]
}
ช่อง
durations[]

string (Duration format)

ค่าระยะเวลาของแถวหนึ่งๆ โดยต้องมีองค์ประกอบเท่ากับ ShipmentModel.duration_distance_matrix_dst_tags

ระยะเวลาเป็นวินาทีที่มีเศษทศนิยมได้สูงสุด 9 หลัก โดยลงท้ายด้วย s เช่น "3.5s"
meters[]

number

ค่าระยะทางของแถวหนึ่งๆ หากไม่มีต้นทุนหรือข้อจำกัดที่อ้างอิงถึงระยะทางในโมเดล คุณก็ปล่อยฟิลด์นี้ว่างไว้ได้ แต่หากมี ฟิลด์นี้ต้องมีองค์ประกอบเท่ากับ durations

TransitionAttributes

ระบุแอตทริบิวต์ของการเปลี่ยนระหว่างการเข้าชม 2 ครั้งติดต่อกันในเส้นทาง TransitionAttributes หลายรายการอาจใช้กับการเปลี่ยนผ่านเดียวกันได้ ในกรณีนี้ ระบบจะรวมค่าใช้จ่ายเพิ่มเติมทั้งหมดเข้าด้วยกันและใช้ข้อจำกัดหรือขีดจำกัดที่เข้มงวดที่สุด (ตามความหมายของ "AND" ที่เป็นธรรมชาติ)

การแสดง JSON 
{
  "srcTag": string,
  "excludedSrcTag": string,
  "dstTag": string,
  "excludedDstTag": string,
  "cost": number,
  "costPerKilometer": number,
  "distanceLimit": {
    object (DistanceLimit)
  },
  "delay": string
}
ช่อง
srcTag

string

แท็กที่กําหนดชุดการเปลี่ยน (src->dst) ที่แอตทริบิวต์เหล่านี้มีผล

การเข้าชมแหล่งที่มาหรือจุดเริ่มต้นของยานพาหนะจะตรงกันก็ต่อเมื่อ VisitRequest.tags หรือ Vehicle.start_tags ของแหล่งที่มามี srcTag หรือไม่มี excludedSrcTag (ขึ้นอยู่กับว่าช่องใดใน 2 ช่องนี้ไม่ว่างเปล่า)
excludedSrcTag

string

ดูsrcTag srcTag และ excludedSrcTag ต้องไม่ว่างเปล่าอย่างใดอย่างหนึ่ง
dstTag

string

การเข้าชมปลายทางหรือจุดสิ้นสุดของยานพาหนะจะตรงกันก็ต่อเมื่อ VisitRequest.tags หรือ Vehicle.end_tags มี dstTag หรือไม่มี excludedDstTag (ขึ้นอยู่กับว่าช่องใดช่องหนึ่งไม่ว่างเปล่า)
excludedDstTag

string

ดูdstTag dstTag และ excludedDstTag ต้องไม่ว่างเปล่าอย่างใดอย่างหนึ่ง
cost

number

ระบุค่าใช้จ่ายในการดำเนินการเปลี่ยนนี้ ค่านี้อยู่ในรูปแบบเดียวกับค่าใช้จ่ายอื่นๆ ทั้งหมดในโมเดลและต้องไม่ติดลบ โดยจะมีผลเพิ่มเติมจากค่าใช้จ่ายอื่นๆ ทั้งหมดที่มีอยู่
costPerKilometer

number

ระบุต้นทุนต่อกิโลเมตรที่ใช้กับระยะทางที่เดินทางขณะทำการเปลี่ยนนี้ ซึ่งจะรวมกับ Vehicle.cost_per_kilometer ที่ระบุไว้ในยานพาหนะ
distanceLimit

object (DistanceLimit)

ระบุขีดจํากัดของระยะทางที่เดินทางขณะทําการเปลี่ยนนี้

ในเดือนมิถุนายน 2021 ระบบจะรองรับเฉพาะขีดจำกัดที่ไม่บังคับเท่านั้น
delay

string (Duration format)

ระบุความล่าช้าที่เกิดขึ้นเมื่อทำการเปลี่ยนนี้

ความล่าช้านี้จะเกิดขึ้นหลังจากการเข้าชมแหล่งที่มาสิ้นสุดลงและก่อนเริ่มการเข้าชมปลายทางเสมอ

ระยะเวลาเป็นวินาทีที่มีเศษทศนิยมได้สูงสุด 9 หลัก โดยลงท้ายด้วย s เช่น "3.5s"

ShipmentTypeIncompatibility

ระบุความเข้ากันไม่ได้ระหว่างการจัดส่งโดยขึ้นอยู่กับ shipmentType การแสดงการจัดส่งที่เข้ากันไม่ได้ในเส้นทางเดียวกันจะถูกจำกัดตามโหมดที่เข้ากันไม่ได้

การแสดง JSON 
{
  "types": [
    string
  ],
  "incompatibilityMode": enum (IncompatibilityMode)
}
ช่อง
types[]

string

รายการประเภทที่ใช้ร่วมกันไม่ได้ การจัดส่ง 2 รายการที่มี shipment_types ต่างกันในรายการที่แสดงจะถือว่า "เข้ากันไม่ได้"
incompatibilityMode

enum (IncompatibilityMode)

โหมดที่ใช้กับการทำงานร่วมกันไม่ได้

IncompatibilityMode

โหมดที่กําหนดวิธีจํากัดการแสดงผลของการจัดส่งที่เข้ากันไม่ได้ในเส้นทางเดียวกัน

Enum
INCOMPATIBILITY_MODE_UNSPECIFIED โหมดที่เข้ากันไม่ได้ซึ่งไม่ได้ระบุ ไม่ควรใช้ค่านี้
NOT_PERFORMED_BY_SAME_VEHICLE ในโหมดนี้ การจัดส่ง 2 รายการที่มีประเภทไม่เข้ากันได้จะใช้ยานพาหนะคันเดียวกันไม่ได้
NOT_IN_SAME_VEHICLE_SIMULTANEOUSLY

สำหรับการจัดส่ง 2 รายการที่มีประเภทที่ใช้ร่วมกันไม่ได้กับโหมดการทำงานร่วมกันไม่ได้ของ NOT_IN_SAME_VEHICLE_SIMULTANEOUSLY ให้ทำดังนี้

  • หากทั้ง 2 รายการเป็นการไปรับสินค้าเท่านั้น (ไม่มีการนำส่ง) หรือการนําส่งเท่านั้น (ไม่มีการไปรับสินค้า) รายการดังกล่าวจะใช้ยานพาหนะคันเดียวกันไม่ได้เลย
  • หากการจัดส่งรายการใดรายการหนึ่งเป็นการนําส่งและอีกรายการเป็นการไปรับ การจัดส่งทั้ง 2 รายการจะใช้ยานพาหนะคันเดียวกันได้ก็ต่อเมื่อมีการนําส่งการจัดส่งรายการแรกก่อนมีการไปรับการจัดส่งรายการที่ 2

ShipmentTypeRequirement

ระบุข้อกำหนดระหว่างการจัดส่งตาม shipmentType ข้อมูลจำเพาะของข้อกำหนดจะกำหนดโดยโหมดข้อกำหนด

การแสดง JSON 
{
  "requiredShipmentTypeAlternatives": [
    string
  ],
  "dependentShipmentTypes": [
    string
  ],
  "requirementMode": enum (RequirementMode)
}
ช่อง
requiredShipmentTypeAlternatives[]

string

รายการประเภทการจัดส่งทางเลือกที่ dependentShipmentTypes กำหนด
dependentShipmentTypes[]

string

การจัดส่งทั้งหมดที่มีประเภทในช่อง dependentShipmentTypes ต้องมีการจัดส่งประเภท requiredShipmentTypeAlternatives อย่างน้อย 1 รายการที่จะเข้าชมในเส้นทางเดียวกัน

หมายเหตุ: ไม่อนุญาตให้ใช้เงื่อนไขแบบเชน เช่น shipmentType ขึ้นอยู่กับตัวเอง
requirementMode

enum (RequirementMode)

โหมดที่ใช้กับข้อกําหนด

RequirementMode

โหมดที่กำหนดลักษณะของการจัดส่งแบบมีความสัมพันธ์ในเส้นทาง

Enum
REQUIREMENT_MODE_UNSPECIFIED โหมดข้อกำหนดที่ไม่ได้ระบุ ไม่ควรใช้ค่านี้
PERFORMED_BY_SAME_VEHICLE ในโหมดนี้ การจัดส่ง "ที่ต้องอาศัย" ทั้งหมดต้องใช้ยานพาหนะเดียวกันกับการจัดส่ง "ที่ต้องใช้" อย่างน้อย 1 รายการ
IN_SAME_VEHICLE_AT_PICKUP_TIME

เมื่อใช้โหมด IN_SAME_VEHICLE_AT_PICKUP_TIME การจัดส่ง "ที่ต้องอาศัย" ทั้งหมดต้องมีการจัดส่ง "ที่ต้อง" อย่างน้อย 1 รายการในยานพาหนะ ณ เวลาที่รับ

ดังนั้นการรับพัสดุ "แบบมีเงื่อนไข" จึงต้องมีอย่างใดอย่างหนึ่งต่อไปนี้

  • การจัดส่ง "ต้องระบุ" สำหรับการนำส่งเท่านั้นซึ่งนำส่งในเส้นทางหลังจากหรือ
  • การจัดส่ง "ที่จำเป็น" ที่รับในเส้นทางก่อนหน้า และหากการจัดส่ง "ที่จำเป็น" มีการนำส่ง การนำส่งนี้จะต้องดำเนินการหลังจากการไปรับของการจัดส่ง "ที่ต้องอาศัย"
IN_SAME_VEHICLE_AT_DELIVERY_TIME เช่นเดียวกับก่อนหน้านี้ ยกเว้นการจัดส่งที่ "ขึ้นอยู่กับ" จะต้องมีการจัดส่งที่ "จำเป็น" ในยานพาหนะ ณ เวลานำส่ง

PrecedenceRule

กฎลําดับความสําคัญระหว่าง 2 เหตุการณ์ (แต่ละเหตุการณ์คือการไปรับหรือการนำส่งการจัดส่ง): เหตุการณ์ "ที่ 2" ต้องเริ่มต้นหลังจากเหตุการณ์ "ที่ 1" เริ่มต้นอย่างน้อย offsetDuration

ลําดับความสําคัญหลายรายการอาจอ้างอิงถึงเหตุการณ์เดียวกัน (หรือที่เกี่ยวข้อง) เช่น "การไปรับ B เกิดขึ้นหลังจากการนำส่ง A" และ "การไปรับ C เกิดขึ้นหลังจากการไปรับ B"

นอกจากนี้ ลําดับความสําคัญจะมีผลก็ต่อเมื่อมีการจัดส่งทั้ง 2 รายการเท่านั้น มิเช่นนั้นระบบจะไม่สนใจ

การแสดง JSON 
{
  "firstIsDelivery": boolean,
  "secondIsDelivery": boolean,
  "offsetDuration": string,
  "firstIndex": integer,
  "secondIndex": integer
}
ช่อง
firstIsDelivery

boolean

ระบุว่าเหตุการณ์ "แรก" เป็นการนําส่งหรือไม่
secondIsDelivery

boolean

ระบุว่าเหตุการณ์ "ที่ 2" เป็นการแสดงโฆษณาหรือไม่
offsetDuration

string (Duration format)

ส่วนต่างระหว่างเหตุการณ์ "แรก" กับ "ที่ 2" อาจเป็นค่าลบได้

ระยะเวลาเป็นวินาทีที่มีเศษทศนิยมได้สูงสุด 9 หลัก โดยลงท้ายด้วย "s" เช่น "3.5s"
firstIndex

integer

ดัชนีการจัดส่งของเหตุการณ์ "แรก" ต้องระบุข้อมูลในช่องนี้
secondIndex

integer

ดัชนีการจัดส่งของเหตุการณ์ "ที่ 2" ต้องระบุข้อมูลในช่องนี้