पाथफाइंडिंग एल्गोरिदम को प्रतिबंधित आंदोलन में कैसे अनुकूलित करें?

Question

कार-जैसे आंदोलन की कल्पना करें जहां इकाइयां एक समय पर चालू नहीं हो सकती हैं। कहें, चर्चा के लिए, कि जब गति से वे प्रति सेकंड 90 डिग्री बदल सकते हैं। यह कई मामलों में इष्टतम पथ को बदल देगा और इसलिए पथ-प्रदर्शक। यह 'सामान्य' पथों को भी पूरी तरह से असंभव बना सकता है।

क्या कोई पथप्रदर्शक एल्गोरिदम या आंदोलन नियोजन एल्गोरिदम हैं जो इसे ध्यान में रख सकते हैं, या लोकप्रिय लोगों को अनुकूलित करने के सरल तरीके हैं?

Comments

क्या पाथफाइंडिंग में गति-डेटा भी शामिल होगा? जैसे, ए से बी तक एक्स किमी / घंटा (या मील प्रति घंटे) पर जाएं, या यह एक स्थिर गति होगी? धीमी गति पर भी 90 डिग्री प्रति सेकंड, एक बहुत ही बंद मोड़ हो सकता है, शायद शारीरिक रूप से भी असंभव है। (जब तक आपके पास सभी 4 पहियों में xD नहीं है)

— ब्रायन एच।

@BrianH। इसलिए मैंने why एट-स्पीड ’कहा। उचित परिस्थितियों में न्यूनतम और अधिकतम सीमाएं होंगी। लेकिन आदर्श रूप में मेरे पास एक 'आदर्श' पथ के लिए एक एल्गोरिथ्म होगा, जिसमें गति भिन्नताएं शामिल हो सकती हैं।

— वीकर ई।

मुझे यह एक बहुत ही दिलचस्प सवाल लगता है, मुझ से एक +1 मिला, कुछ साफ जवाब देखने के लिए इंतजार नहीं किया जा सकता :) :)

— ब्रायन एच।

सीमित मोड़ गति के साथ आंदोलन की योजना के बारे में एक पिछला सवाल था , जो उपयोग का भी हो सकता है।

— DMGregory

मैं इसे किसी प्रकार की अदृश्य दीवार मानूंगा। इसके अलावा, अधिकांश पथ फंडिंग एल्गोरिथ्म में प्रत्येक पथ के लिए एक "वजन" है (उदाहरण के लिए, पानी में चलना भूमि पर चलने की तुलना में धीमा है), इसलिए आप उस पथ पर अतिरिक्त वजन जोड़ सकते हैं जो प्राप्त करना कठिन है। यह सब केवल कार की गति और दिशा के साथ ही जाना जा सकता है।

— the_lotus

Answer 1

गैर-समग्र आर्थिक योजना की अद्भुत दुनिया में आपका स्वागत है । मैं एक जाली ग्रिड पथ योजनाकार का उपयोग करके ऐसा करने की सलाह देता हूं । अन्य विकल्पों में किनाडायनामिक आरआरटी , और प्रक्षेपवक्र अनुकूलन शामिल हैं । गैर-होलोनोमिक सिस्टम में कार, नाव, यूनीसाइकिल, या वास्तव में कुछ भी शामिल है जहां वाहन किसी भी दिशा में यात्रा नहीं कर सकता है। इन प्रणालियों की योजना होलोनोमिक प्रणालियों की तुलना में बहुत कठिन है और ~ 2000 तक शैक्षणिक अनुसंधान के किनारे पर थी। आजकल चुनने के लिए बहुत सारे एल्गोरिदम हैं, जो शालीनता से काम करते हैं।

यहां देखिए यह कैसे काम करता है।

राज्य

आपकी कार का कॉन्फ़िगरेशन क्यू वास्तव में कार की एक्स, वाई स्थिति और इसके अभिविन्यास टी युक्त 3 डी राज्य है । आपके ए * एल्गोरिथ्म में नोड वास्तव में 3 डी वैक्टर हैं।

class Node
{
    // The position and orientation of the car.
    float x, y, theta;
}

क्रिया

तो किनारों का क्या?

यह थोड़ा कठिन है, क्योंकि आपकी कार वास्तव में पहिया को चालू करने के लिए अनंत तरीके चुन सकती है । इसलिए, हम कार को असतत सेट, ए पर ले जा सकने वाली क्रियाओं की संख्या को सीमित करके एक जाली ग्रिड प्लानर के लिए इसे सुलभ बना सकते हैं । सादगी के लिए मान लें कि कार में तेजी नहीं है, बल्कि इसके वेग को तुरंत बदल सकता है। हमारे मामले में, ए इस प्रकार हो सकता है:

class Action
{
    // The direction of the steering wheel.
    float wheelDirection;

    // The speed to go at in m/s.
    float speed;

    // The time that it takes to complete an action in seconds.
    float dt;
}

अब, हम कार्यों का एक असतत सेट बना सकते हैं जो कार किसी भी समय ले सकती है। उदाहरण के लिए, 0.5 सेकंड के लिए पूरी तरह से गैस को दबाते समय एक कठोर अधिकार इस तरह दिखाई देगा:

Action turnRight;
turnRight.speed = 1;
turnRight.wheelDirection = 1;
turnRight.dt = 0.5;

कार को रिवर्स और बैक अप में लाना इस तरह होगा:

Action reverse;
reverse.speed = -1;
reverse.wheelDirection = 0;
reverse.dt = 0.5;

और आपके कार्यों की सूची इस तरह दिखाई देगी:

List<Action> actions = { turnRight, turnLeft, goStraight, reverse ...}

आपको यह परिभाषित करने के तरीके की भी ज़रूरत है कि नोड पर की गई कार्रवाई नए नोड में कैसे परिणाम देती है। इसे सिस्टम की आगे की गतिशीलता कहा जाता है।

// These forward dynamics are for a dubin's car that can change its
// course instantaneously.
Node forwardIntegrate(Node start, Action action) 
{
    // the speed of the car in theta, x and y.
    float thetaDot = action.wheelDirection * TURNING_RADIUS;

    // the discrete timestep in seconds that we integrate at.
    float timestep = 0.001;

    float x = start.x;
    float y = start.y;
    float theta = start.theta;

    // Discrete Euler integration over the length of the action.
    for (float t = 0; t < action.dt; t += timestep)
    {
       theta += timestep * thetaDot;
       float xDot = action.speed * cos(theta);
       float yDot = action.speed * sin(theta);
       x += timestep * xDot;
       y += timestep * yDot;
    }

    return Node(x, y, theta);
}

असतत ग्रिड कोशिकाओं

अब, जाली ग्रिड का निर्माण करने के लिए, हमें कार के राज्यों को असतत ग्रिड कोशिकाओं में हैश करने की आवश्यकता है । यह उन्हें असतत नोड्स में बदल देता है जो ए * द्वारा पीछा किया जा सकता है। यह अति-महत्वपूर्ण है क्योंकि अन्यथा A * में यह जानने का कोई तरीका नहीं होगा कि दो कार राज्य वास्तव में उनकी तुलना करने के लिए समान हैं या नहीं। हैशिंग से पूर्णांक ग्रिड सेल मानों तक, यह तुच्छ हो जाता है।

GridCell hashNode(Node node)
{
    GridCell cell;
    cell.x = round(node.x / X_RESOLUTION);
    cell.y = round(node.y / Y_RESOLUTION);
    cell.theta = round(node.theta / THETA_RESOLUTION);
    return cell; 
}

अब, हम एक ए * योजना कर सकते हैं जहां ग्रिडसील्स नोड्स हैं, एक्ट्स नोड्स के बीच के किनारे हैं, और ग्रिडसील्स के संदर्भ में स्टार्ट और गोल व्यक्त किए जाते हैं। दो GridCells के बीच अनुमानी x और y के बीच की दूरी है, जो थीटा में कोणीय दूरी है।

पथ का अनुसरण

अब जब हमारे बीच ग्रिडस्केल्स और क्रियाओं के संदर्भ में एक रास्ता है, तो हम कार के लिए एक पथ अनुयायी लिख सकते हैं। चूँकि ग्रिड कोशिकाएँ असतत होती हैं, इसलिए कार इनबिल्टीन कोशिकाओं को कूदती है। इसलिए हमें रास्ते में कार की गति को सुचारू करना होगा। यदि आपका गेम एक भौतिकी इंजन का उपयोग कर रहा है, तो इसे स्टीयरिंग कंट्रोलर लिखकर पूरा किया जा सकता है जो कार को रास्ते के करीब रखने की कोशिश करता है। अन्यथा, आप बीज़ियर कर्व्स का उपयोग करके पथ को चेतन कर सकते हैं या बस पथ के निकटतम कुछ बिंदुओं से औसत कर सकते हैं।

Comments

उत्कृष्ट पोस्ट (और इससे भी छोटी! मैं नावों के लिए कुछ ऐसा ही करता हूं - फिसलन :-)। ओटोह, अधिक जगह है,

— स्टॉर्मविंड

Answer 2

अधिकांश पथ खोजने वाले एल्गोरिदम ज्यामिति के प्रतिबंध के बिना एक मनमाना ग्राफ पर काम करते हैं।

तो आपको जो करने की ज़रूरत है वह प्रत्येक खोजे गए नोड में कार का ओरिएंटेशन जोड़ सकता है और प्रतिबंधित कर सकता है कि कौन से नोड वास्तव में जुड़े हुए हैं।

Comments

समस्या यह है कि कार अलग-अलग दिशाओं से आने वाले एक ही नोड का दौरा कर सकती है, जो उन कनेक्शनों पर अलग-अलग प्रतिबंध लगाती है जो वहां से अलग हो सकते हैं।

— वीकर ई।

@WeckarE। लेकिन कार एक ही नोड पर नहीं जाती है। यह 2 नोड्स का दौरा करता है जो एक ही स्थान पर होते हैं लेकिन अलग-अलग अभिविन्यास होते हैं

— शाफ़्ट फ्रीक

@WeckarE। दो अलग नोड्स के रूप में उन का इलाज करें। भौतिक ग्राफ़ और लॉजिकल ग्राफ़ को बिल्कुल समान होने की आवश्यकता नहीं है।

— ब्लूराजा - डैनी पफ्लुघोटे

Answer 3

मेरे विचारों, havent ने उनका परीक्षण किया!

1. प्रारंभ से गंतव्य तक A * चलाएं , पथ वापस लौटें।
2. पथ के माध्यम से लूप करें, जब आप एक मोड़ का पता लगाते हैं, तो एक बीज़ियर एल्गोरिथ्म (या किसी भी तरह का) का उपयोग करें जो साधक वर्तमान गति का उपयोग करके नोड्स की भविष्यवाणी करता है जो एक चिकनी मोड़ बनाएगा। सुनिश्चित करें कि यह निकटतम पथ-नोड पर वापस जाने की कोशिश करता है।
3. यदि मोड़ किया जा सकता है, तो महान, यदि नहीं, तो धीमी गति के साथ दोहराएं, तेज मोड़ के लिए बना।
4. एक बार सही रास्ता बन जाने के बाद, मोड़ से पहले साधक की गति को समायोजित करने वाले मार्ग से वापस जाएं, ताकि मोड़ शुरू होने से पहले वह सही गति तक धीमा हो जाए।
5. यदि मोड़ बिल्कुल नहीं बनाया जा सकता है, तो पूरी चीज़ को फिर से चलाएं। बस सुनिश्चित करें कि चालू किए जाने वाले सभी बंद नोड्स बंद सूची में नहीं हैं, इसलिए उन्हें अनदेखा किया गया है। और आप उस बिंदु से शुरू कर सकते हैं जहां मोड़ शुरू किया गया है ताकि आप पथ के succesfull भाग को छोड़ सकें, हालांकि, कुछ मामलों में यह संभवतः इष्टतम पथ से कम परिणाम हो सकता है।

आपको पहले पथ को पूरा किए बिना भी ऐसा करने में सक्षम होना चाहिए, एर्गो: ए * के दौरान हैंडलिंग मुड़ता है, जो शायद बहुत बेहतर अनुकूलित होगा, लेकिन यह समस्याग्रस्त और गड़बड़ भी साबित हो सकता है, मैं वास्तव में नहीं जानता और दुर्भाग्य से मैं कर सकता हूं खुद को परखने का समय नहीं है।

Answer 4

यदि आपके एजेंट के पास कार का पूरा नियंत्रण है, तो इसे दूसरे तरीके से करें। पहले शुरू से अंत तक एक लाइन कनेक्ट करें, फिर यह पता लगाएं कि आप डेनिस के जवाब के समान प्रत्येक गति को किस गति से नेविगेट कर सकते हैं।

हालांकि तय बिंदुओं से बेजियर कर्व्स न खींचे। स्पीड लॉस को कम करने के लिए आपको पूरी लाइन को इधर-उधर करने की जरूरत होती है, इसलिए कम या ज्यादा दूरी पर अतिरिक्त नोड्स लगाकर शुरुआत करें और फिर एनर्जी मिनिमाइजेशन या इसी तरह की रणनीतियों के लिए आगे बढ़ें। विवरण के लिए आपको एआई लाइन जनरेशन (अधिमानतः सिम या सेमी-सिम) रेसिंग गेम्स में देखने की जरूरत है।

एक बार जब आपके पास AI लाइन सिस्टम चल रहा हो, तो अपनी A * खोज को चलाएं और प्रत्येक पथ के लिए कम से कम एक कोने आगे बढ़ें, फिर AI लाइन की गणना करें जो आपको एक समय का अनुमान देती है। यह आपकी लागत समारोह होगी।