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 โดยใช้เมทริกซ์ "เร็ว"
  • รถ 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_types ที่เข้ากันไม่ได้ (ดู 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" เป็นต้น หากคีย์ที่ระบุไม่ปรากฏในแผนที่ ระบบจะถือว่าการโหลดที่เกี่ยวข้องเป็นค่าว่าง
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 เป็นต้นมา ระบบจะรองรับการอ้อมเมื่อระยะเวลาการเดินทางไม่ขึ้นอยู่กับยานพาหนะเท่านั้น

ระยะเวลาเป็นวินาทีที่มีเศษทศนิยมได้สูงสุด 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

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

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

number

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

number

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

จุดบอกทาง

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

การแสดง 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

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

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

object (Location)

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

string

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

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

ตำแหน่ง

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

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

object (LatLng)

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

integer

เข็มทิศที่เชื่อมโยงกับทิศทางการไหลของการเข้าชม ค่านี้ใช้เพื่อระบุฝั่งของถนนที่จะใช้สำหรับการรับและส่ง ค่า Heading จะมีตั้งแต่ 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 เสมอ และใช้ตัวเลขเศษส่วน 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

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

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

ปริมาณการโหลดที่สูงกว่าเกณฑ์ซึ่งจะทำให้ต้นทุนในการย้ายหน่วยการโหลดเปลี่ยนจาก 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

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

string (Duration format)

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

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

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

string (Duration format)

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

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

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

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

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

ระยะเวลาเป็นวินาทีที่มีเศษทศนิยมได้สูงสุด 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

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

การเริ่มต้นของยานพาหนะแต่ละครั้งต้องตรงกับเมตริก 1 รายการเท่านั้น กล่าวคือ ฟิลด์ 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 หลายรายการอาจมีผลกับการเปลี่ยนผ่านเดียวกัน ในกรณีนี้ ค่าใช้จ่ายเพิ่มเติมทั้งหมดจะรวมกัน และข้อจำกัดหรือขีดจำกัดที่เข้มงวดที่สุดจะมีผล (ตามความหมายของ "และ" ตามธรรมชาติ)

การแสดง 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 เสมอ

ระยะเวลาเป็นวินาทีที่มีเศษทศนิยมได้สูงสุด 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 รายการที่มีประเภทไม่เข้ากันจะอยู่ในยานพาหนะเดียวกันพร้อมกันไม่ได้

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

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

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

integer

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

integer

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