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 คุณอาจต้องตั้งค่าช่วงเวลานี้ให้สั้นลงเพื่อเพิ่มประสิทธิภาพ (เช่น หากคุณสร้างโมเดลวันเดียว คุณควรตั้งค่าขีดจํากัดเวลาทั่วโลกเป็นวันนั้น) หากไม่ได้ตั้งค่า ระบบจะใช้ 00:00:00 UTC, 1 มกราคม 1970 (เช่น วินาที: 0, นาโน: 0) เป็นค่าเริ่มต้น

ใช้ RFC 3339 โดยเอาต์พุตที่สร้างขึ้นจะได้รับการแปลงเป็นรูปแบบ Z เสมอ และใช้ตัวเลขเศษส่วน 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 เสมอ และใช้ตัวเลขเศษส่วน 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 โดยใช้เมทริกซ์ "fast"
  • รถ 1 คันเริ่มเส้นทางที่ locB และสิ้นสุดที่ locB โดยใช้เมทริกซ์ "ช้า"
  • ยานพาหนะ 1 คันเริ่มเส้นทางที่ locB และสิ้นสุดที่ locB โดยใช้เมทริกซ์ "fast"
  • คำขอเข้าชมเพื่อรับสินค้า 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 ที่ระบุจะต้องตรงกับแท็ก 1 รายการในช่องนี้ โปรดทราบว่าแท็กต้นทาง ปลายทาง และเมทริกซ์ของ Vehicle อาจเหมือนกัน เช่นเดียวกับแท็กต้นทางและปลายทางของ VisitRequest แท็กทั้งหมดต้องแตกต่างกันและต้องไม่ใช่สตริงว่าง หากช่องนี้ไม่ว่าง durationDistanceMatrices ต้องไม่ว่าง
durationDistanceMatrixDstTags[]

string

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

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

object (TransitionAttributes)

เพิ่มแอตทริบิวต์การเปลี่ยนฉากลงในโมเดลแล้ว
shipmentTypeIncompatibilities[]

object (ShipmentTypeIncompatibility)

ชุด shipment_type ที่เข้ากันไม่ได้ (ดู ShipmentTypeIncompatibility)
shipmentTypeRequirements[]

object (ShipmentTypeRequirement)

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

object (PrecedenceRule)

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

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

integer

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

การจัดส่ง

การจัดส่งสินค้า 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" เป็นต้น หากคีย์ที่ระบุไม่ปรากฏในแผนที่ ระบบจะถือว่าการโหลดที่เกี่ยวข้องเป็น Null
allowedVehicleIndices[]

integer

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

number

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

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

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

integer

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

string (Duration format)

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

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

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

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

string (Duration format)

ระบุระยะเวลาสูงสุดตั้งแต่เริ่มรับสินค้าจนถึงเริ่มนำส่งสินค้า หากระบุ ต้องเป็นค่าที่ไม่เป็นลบ และการจัดส่งต้องมีการรับสินค้าและการนำส่งอย่างน้อย 1 รายการ โดยไม่ขึ้นอยู่กับตัวเลือกอื่นที่เลือกสำหรับการรับสินค้าและนำส่ง หรือความเร็วของยานพาหนะ โดยระบุได้ควบคู่ไปกับข้อจํากัดการอ้อมสูงสุด ซึ่งโซลูชันจะปฏิบัติตามข้อกําหนดทั้ง 2 รายการ
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)
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]

จุดบอกทาง

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

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

  // The following is a list of mutually exclusive fields. At most one of the
  // fields will be set in a response:
  "location": {
    object (Location)
  },
  "placeId": string
  // End of mutually exclusive fields.
}
ฟิลด์
sideOfRoad

boolean

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

boolean

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

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

object (Location)

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

string

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

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

ตำแหน่ง

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

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

object (LatLng)

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

integer

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

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 เสมอ และใช้ตัวเลขเศษส่วน 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 เสมอ และใช้ตัวเลขเศษส่วน 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 เสมอ และใช้ตัวเลขเศษส่วน 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 เสมอ และใช้ตัวเลขเศษส่วน 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

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

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

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

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

RouteModifiers

แคปซูลชุดเงื่อนไขที่ไม่บังคับเพื่อตอบสนองเมื่อคำนวณเส้นทางของยานพาหนะ ซึ่งคล้ายกับ RouteModifiers ใน Google Maps Platform Routes Preferred API โปรดดู 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 ตามเส้นทางของยานพาหนะนี้ จะมีการปรับค่าใช้จ่ายต่อไปนี้ (ครั้งเดียวต่อยานพาหนะ): (น้ำหนักบรรทุก - 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 ชั่วโมงสำหรับยานพาหนะนี้

ทดลอง: ดูรายละเอียดเพิ่มเติมได้ที่ 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)

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

number

ต้นทุนในการย้ายหน่วยของภาระงานสำหรับแต่ละหน่วยระหว่าง 0 กับเกณฑ์ ต้องเป็นค่าที่สิ้นสุดและมากกว่าหรือเท่ากับ 0
costPerUnitAboveThreshold

number

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

DurationLimit

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

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

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

string (Duration format)

ขีดจำกัดที่เข้มงวดซึ่งจำกัดระยะเวลาให้ไม่เกิน maxDuration
softMaxDuration

string (Duration format)

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

หากกำหนดไว้ softMaxDuration ต้องไม่ใช่ค่าติดลบ หากกำหนด maxDuration ด้วย softMaxDuration ต้องน้อยกว่า maxDuration
quadraticSoftMaxDuration

string (Duration format)

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

หากตั้งค่า quadraticSoftMaxDuration จะต้องเป็นไปตามเงื่อนไขต่อไปนี้

  • ต้องไม่ติดลบ
  • ต้องกำหนด maxDuration
  • quadraticSoftMaxDuration ต้องน้อยกว่า maxDuration
  • ความแตกต่างต้องไม่เกิน 1 วัน: maxDuration - quadraticSoftMaxDuration <= 86400 seconds
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 เสมอ และใช้ตัวเลขเศษส่วน 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 เสมอ และใช้ตัวเลขเศษส่วน 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)

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

FrequencyConstraint

นอกจากนี้ คุณยังจำกัดความถี่และระยะเวลาของช่วงพักที่ระบุไว้ข้างต้นได้โดยบังคับใช้ความถี่ขั้นต่ำของช่วงพัก เช่น "ต้องมีช่วงพักอย่างน้อย 1 ชั่วโมงทุกๆ 12 ชั่วโมง" หากตีความได้ว่า "ภายในกรอบเวลาแบบเลื่อนใดๆ 12 ชั่วโมง จะต้องมีช่วงพักอย่างน้อย 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
maxInterBreakDuration

string (Duration format)

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

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

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

ทดลอง: ดูรายละเอียดเพิ่มเติมได้ที่ 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

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

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

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

แถว

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

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

string (Duration format)

ค่าระยะเวลาสำหรับแถวที่ระบุ โดยต้องมีองค์ประกอบเท่ากับ ShipmentModel.duration_distance_matrix_dst_tags
meters[]

number

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

TransitionAttributes

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

การแสดง 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 (ขึ้นอยู่กับว่าฟิลด์ใดใน 2 ฟิลด์นี้ไม่ใช่ฟิลด์ว่าง)
excludedDstTag

string

ดูdstTag dstTag และ excludedDstTag ต้องมีค่าอย่างใดอย่างหนึ่ง
cost

number

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

number

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

object (DistanceLimit)

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

ตั้งแต่เดือนมิถุนายน 2021 เป็นต้นไป ระบบจะรองรับเฉพาะขีดจำกัดแบบยืดหยุ่น
delay

string (Duration format)

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

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

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 รายการที่มีประเภทไม่เข้ากันจะอยู่ในยานพาหนะคันเดียวกันพร้อมกันไม่ได้

  • โดยจะแชร์ยานพาหนะคันเดียวกันได้ก็ต่อเมื่อมีการนำส่งก่อนที่จะมีการรับอีกครั้ง
  • หากการจัดส่งทั้ง 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" ต้องเริ่มต้นอย่างน้อย 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)

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

integer

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

integer

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