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 ต้องอยู่ภายใน 31,536,000 วินาทีของกันและกัน

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

integer

ชุดยานพาหนะที่อาจทำการจัดส่งนี้ หากเว้นว่างไว้ ยานพาหนะทั้งหมดอาจดำเนินการได้ ยานพาหนะจะระบุตามดัชนีในรายการ vehicles ของ ShipmentModel
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

ออบเจ็กต์ที่แสดงคู่ละติจูด/ลองจิจูด ซึ่งจะแสดงเป็นคู่ของค่า 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,

  // 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

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

boolean

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

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

object (Location)

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

string

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

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

ตำแหน่ง

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

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

object (LatLng)

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

integer

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

TimeWindow

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

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

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

string (Timestamp format)

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

ใช้ RFC 3339 โดยเอาต์พุตที่สร้างขึ้นจะได้รับการแปลงเป็นรูปแบบ Z เสมอ และใช้ตัวเลขเศษส่วน 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 โหมดการเดินทางที่สอดคล้องกับเส้นทางเดินเท้า
TWO_WHEELER ยานพาหนะ 2 ล้อที่ใช้เครื่องยนต์ เช่น มอเตอร์ไซค์ โปรดทราบว่ารูปแบบนี้แตกต่างจากรูปแบบการเดินทาง BICYCLING ซึ่งครอบคลุมรูปแบบการเดินทางที่ใช้แรงมนุษย์ โหมดการเดินทางนี้รองรับเฉพาะในประเทศที่ระบุไว้ในประเทศและภูมิภาคที่รองรับยานพาหนะ 2 ล้อ

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 ชั่วโมงสำหรับยานพาหนะนี้

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

และเส้นทางคือเริ่มต้น,รับ,รับ,นำส่ง,นำส่ง,สิ้นสุด โดยมีการเปลี่ยนผ่านดังนี้

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

อย่างไรก็ตาม หากเส้นทางคือเริ่มต้น, รับ, นำส่ง, รับ, นำส่ง, สิ้นสุด โดยมีการเปลี่ยนผ่านดังนี้

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

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

string

แท็กที่กำหนดชุดการเปลี่ยนสถานะ (src->dst) ที่แอตทริบิวต์เหล่านี้ใช้

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

string

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

string

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

string

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

number

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

number

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

object (DistanceLimit)

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

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

string (Duration format)

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

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

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)

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

integer

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

integer

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