रास्ता मैट्रिक्स पाएं

computeRouteMatrix तरीके (REST) या स्ट्रीमिंग ComputeRouteMatrix तरीके (gRPC) को कॉल करके एक से ज़्यादा ऑरिजिन और डेस्टिनेशन के लिए किसी रूट की दूरी और अवधि का हिसाब लगाने के लिए, Routes API का इस्तेमाल करें.

शुरुआत की जगह और मंज़िलों की सूची दिए जाने पर, यह तरीका हर शुरुआत की जगह से शुरू होकर हर मंज़िल पर खत्म होने वाले रास्ते की दूरी और अवधि का हिसाब लगाता है.

बस, मेट्रो वगैरह के रूट का मैट्रिक्स पाएं

आपके पास बस, मेट्रो वगैरह के रूट मैट्रिक्स का हिसाब लगाने का विकल्प भी है. उदाहरण के लिए, बस, मेट्रो वगैरह के लिए रूट मैट्रिक्स पाना देखें.

अनुरोध की सीमाएं

Compute रूट मैट्रिक्स के तरीके, पते या प्लेस आईडी का इस्तेमाल करने वाले वेपॉइंट और एलिमेंट के लिए, नीचे दी गई अनुरोध की सीमाओं को लागू करते हैं. एलिमेंट किसी रूट मैट्रिक्स में हर ऑरिजिन और डेस्टिनेशन के बीच के रूट होते हैं. इसलिए, एलिमेंट की संख्या ऑरिजिन की संख्या और डेस्टिनेशन की संख्या गुना होती है. उदाहरण के लिए, अगर आपके पास 10 ऑरिजिन और 10 डेस्टिनेशन हैं, तो आपके पास 100 एलिमेंट होंगे:

• जो रूट TRANSIT रूट नहीं हैं उनके लिए एलिमेंट की संख्या 625 से ज़्यादा नहीं हो सकती.

• अगर आप TRANSIT रूट तय करते हैं, तो एलिमेंट की संख्या 100 से ज़्यादा नहीं हो सकती.

• TRAFFIC_AWARE_OPTIMAL तय करने पर, एलिमेंट की संख्या 100 से ज़्यादा नहीं हो सकती. TRAFFIC_AWARE_OPTIMAL के बारे में ज़्यादा जानने के लिए, यह तय करें कि ट्रैफ़िक डेटा को कैसे शामिल करना है और क्या करना है.

• अगर पते या जगह के आईडी का इस्तेमाल करके, ऑरिजिन या डेस्टिनेशन की जानकारी दी जाती है, तो इस तरह से कुल 50 पॉइंट तय किए जा सकते हैं.

जवाब से जुड़ी गड़बड़ियां

Compute Route मैट्रिक्स के तरीकों की एक सुविधा यह है कि गड़बड़ियां या तो पूरे रिस्पॉन्स के लिए या अलग-अलग रिस्पॉन्स एलिमेंट के लिए दिखाई जा सकती हैं. उदाहरण के लिए, अगर अनुरोध गलत है, तो पूरे जवाब में गड़बड़ी है (उदाहरण के लिए, उसका ऑरिजिन शून्य है).

हालांकि, अगर रिस्पॉन्स में एलिमेंट के किसी सबसेट पर कोई गड़बड़ी लागू होती है (उदाहरण के लिए, ऑरिजिन और डेस्टिनेशन के एक कॉम्बिनेशन के लिए रूट की गिनती नहीं की जा सकती), तो सिर्फ़ वे एलिमेंट ही गड़बड़ी का कोड दिखाएंगे जिन पर गड़बड़ी का असर हुआ है.

gRPC स्ट्रीम के नतीजे

ComputeRouteMatrix gRPC तरीका, ऑरिजिन और डेस्टिनेशन की सूची लेता है और ऐसी स्ट्रीम दिखाता है जिसमें ऑरिजिन और डेस्टिनेशन के हर कॉम्बिनेशन के लिए रास्ते की जानकारी होती है. नतीजे, स्ट्रीम के तौर पर दिखाए जाते हैं. इसलिए, नतीजों को प्रोसेस करना शुरू करने से पहले, आपको सभी संभावित रास्तों के कॉम्बिनेशन की गिनती होने तक इंतज़ार करने की ज़रूरत नहीं है.

इस बात की कोई गारंटी नहीं है कि स्ट्रीम से लौटाए गए एलिमेंट, किसी भी क्रम में दिखेंगे. इसलिए, हर रिस्पॉन्स एलिमेंट में एक origin_index और destination_index होते हैं. अनुरोध में बताए गए ऑरिजिन और डेस्टिनेशन के लिए, रूट ऑरिजिन, दिए गए एलिमेंट के origins[origin_index] के बराबर होता है और रूट डेस्टिनेशन destinations[destination_index] के बराबर होता है. इन सरणियों को इंडेक्स नहीं किया जाता. ऑरिजिन और डेस्टिनेशन सूची के ऑर्डर सेव करना ज़रूरी है.

रूट मैट्रिक्स के उदाहरण दें

रूट मैट्रिक्स की गणना करने के लिए, एचटीटीपी अनुरोध में computeRouteMatrix तरीके का इस्तेमाल करें.

एचटीटीपी का उदाहरण

यहां दिए गए उदाहरण में, computeRouteMatrix एचटीटीपी अनुरोध के बारे में बताया गया है. इस उदाहरण में, आप:

• दो ऑरिजिन और दो डेस्टिनेशन वेपॉइंट का कलेक्शन तय करें. यह तरीका, हर ऑरिजिन से हर मंज़िल तक के रूट का हिसाब लगाता है, ताकि रिस्पॉन्स में चार रास्ते शामिल हों.

  अरे में, पहला एलिमेंट 0 के इंडेक्स पर होता है और दूसरा एलिमेंट 1 होता है.

• यह बताने के लिए कि response (REST) या ComputeRoutesResponse (gRPC) के कौनसे फ़ील्ड दिखें, यह बताने के लिए रिस्पॉन्स फ़ील्ड मास्क शामिल करें. इस उदाहरण में, हर रूट के लिए originIndex, destinationIndex, duration, distanceMeters, status, और condition लौटाने के अनुरोध को कॉन्फ़िगर करें. ज़्यादा जानकारी के लिए, लौटाने के लिए फ़ील्ड चुनें पर जाएं.

curl -X POST -d '{
  "origins": [
    {
      "waypoint": {
        "location": {
          "latLng": {
            "latitude": 37.420761,
            "longitude": -122.081356
          }
        }
      },
      "routeModifiers": { "avoid_ferries": true}
    },
    {
      "waypoint": {
        "location": {
          "latLng": {
            "latitude": 37.403184,
            "longitude": -122.097371
          }
        }
      },
      "routeModifiers": { "avoid_ferries": true}
    }
  ],
  "destinations": [
    {
      "waypoint": {
        "location": {
          "latLng": {
            "latitude": 37.420999,
            "longitude": -122.086894
          }
        }
      }
    },
    {
      "waypoint": {
        "location": {
          "latLng": {
            "latitude": 37.383047,
            "longitude": -122.044651
          }
        }
      }
    }
  ],
  "travelMode": "DRIVE",
  "routingPreference": "TRAFFIC_AWARE"
}' \
-H 'Content-Type: application/json' -H 'X-Goog-Api-Key: YOUR_API_KEY' \
-H 'X-Goog-FieldMask: originIndex,destinationIndex,duration,distanceMeters,status,condition' \
'https://routes.googleapis.com/distanceMatrix/v2:computeRouteMatrix'

रिस्पॉन्स में सभी ऑरिजिन और डेस्टिनेशन वेपॉइंट के कॉम्बिनेशन के लिए चार संभावित रूट शामिल होते हैं.

originIndex और destinationIndex रिस्पॉन्स फ़ील्ड का इस्तेमाल करके, रिस्पॉन्स में हर रूट की पहचान करें. उदाहरण के लिए, रिस्पॉन्स में 1 का originIndex, अनुरोध में origins कलेक्शन के इंडेक्स 1 पर वेपॉइंट से कैलकुलेट किए गए रूट से मेल खाता है.

[
    {
        "originIndex": 0,
        "destinationIndex": 0,
        "status": {},
        "distanceMeters": 822,
        "duration": "160s",
        "condition": "ROUTE_EXISTS"
    },
    {
        "originIndex": 1,
        "destinationIndex": 0,
        "status": {},
        "distanceMeters": 2919,
        "duration": "361s",
        "condition": "ROUTE_EXISTS"
    },
    {
        "originIndex": 1,
        "destinationIndex": 1,
        "status": {},
        "distanceMeters": 5598,
        "duration": "402s",
        "condition": "ROUTE_EXISTS"
    },
    {
        "originIndex": 0,
        "destinationIndex": 1,
        "status": {},
        "distanceMeters": 7259,
        "duration": "712s",
        "condition": "ROUTE_EXISTS"
    }
]

gRPC के उदाहरण

gRPC अनुरोधों के उदाहरण के लिए, gRPC अनुरोध का उदाहरण देखें. उस पेज पर मौजूद Java का उदाहरण, Compute Routes और Compute Route मैट्रिक्स दोनों को कॉल करता है.