🆑 ⏫ 🧗🏻 3D बिंदु बादलों के 2D अनुभागों में अण्डाकार आर्क्स को पहचानने के लिए OpenCV लाइब्रेरी का उपयोग करना 🐶 👎🏾 ✊🏿

3 डी पॉइंट क्लाउड ( 3DOT ) प्राप्त करने में सक्षम किफायती लेजर स्कैनर (लिडार) के व्यापक प्रसार और विभिन्न क्षेत्रों में इस तकनीक के व्यापक अनुप्रयोग (मैकेनिकल इंजीनियरिंग से सुरक्षा, तेल उद्योग से वास्तुकला तक) के संबंध में, प्रसंस्करण एल्गोरिदम में रुचि को पुनर्जीवित किया गया है। बिंदुओं के बादल। उद्योग में 3 डी डीटीएसएल

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

। फायदे के साथ-साथ तैयार पुस्तकालयों के उपयोग के दृष्टिकोण में नुकसान है। उदाहरण के लिए, उन्हें मौजूदा कडोव प्रसंस्करण योजनाओं में शामिल करना मुश्किल है, जिनमें आमतौर पर 2 डी आयाम होता है।

के पर विचार कैसे इसे संसाधित करने में संभव हो जाएगा करते हैं 3dOT , उदाहरण के लिए, एक पम्पिंग स्टेशन, 2 डी वर्गों के साथ शुरू और 2 डी प्रसंस्करण, जो विश्वसनीय और अनुकूलित छवि प्रसंस्करण पुस्तकालयों में उपलब्ध है, उदाहरण के लिए की पूरी शस्त्रागार का उपयोग कर OpenCV ।

चित्रा 1. एक पंप स्टेशन के 3 डी ओटी मॉडल

विभिन्न पाइप संरचनाओं को स्कैन करके प्राप्त किए गए अनुभागों का मुख्य तत्व अण्डाकार चाप हैं ।

चित्रा 2. औसत स्तर पर एक पंपिंग स्टेशन के 3 डी मॉडल का क्षैतिज क्रॉस सेक्शन।

इस लेख के लिए, हम अपने विचार को एक प्रमुख एल्गोरिथ्म तक सीमित रखते हैं जो हमें मनमाने ढंग से अण्डाकार आर्क्स का पता लगाने की अनुमति देता है - यह आर्क सेगमेंट और क्षेत्र बाइंडिंग ( क्षेत्र विकास और बढ़त लिंकिंग ) की वृद्धि के लिए एक पुनरावृत्ति एल्गोरिथ्म है ।

विकास एल्गोरिदम सांख्यिकीय एल्गोरिदम की तुलना में सबसे स्पष्ट और आसानी से सत्यापित, यद्यपि समय लेने वाली हैं, जो उस मामले के लिए बेहतर अनुकूल हैं जब दृश्य में शिथिल युग्मित, दूर की वस्तुएं होती हैं जो एक दीर्घवृत्त से संबंधित होती हैं। इन एल्गोरिदम पर भविष्य के लेखों में चर्चा की जाएगी।

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

हम मानते हैं कि हमें इस छवि में एक अण्डाकार चाप का पता लगाने (पहचानने, वर्गीकृत करने) की आवश्यकता है (यानी दीर्घवृत्त के मापदंडों के साथ-साथ दीर्घवृत्त चाप के प्रारंभिक और अंतिम कोण की गणना), जो बादल के क्षैतिज खंड से बाहर की ओर है।

चित्रा 3. 3 डी मॉडल के क्रॉस सेक्शन के अण्डाकार चाप में से एक (चौरसाई के बाद)

नेत्रहीन रूप से रेखापुंज के साथ काम को कम करने के लिए, हम रूपरेखा के माध्यम से रेखापुंज के साथ सभी संचालन करेंगे ।

OpenCV findContours प्रक्रिया रैस्टर मैट पर सभी बाहरी (आंतरिक आकृतियों के बिना) पूर्णांक बिंदु वैक्टर के एक वेक्टर (रेखापुंज निर्देशांक में ) के रूप में मिलती है :

 Mat mat(size);
 vector<vector<Point>> contours;
 findContours(mat, contours, RETR_EXTERNAL, CHAIN_APPROX_SIMPLE);

यह हमारा महत्वपूर्ण ऑपरेशन है, जो कुछ सरल मामलों में कार्य को पूरी तरह से हल करता है । लेकिन चूंकि पतित मामले हमेशा नहीं पाए जाते हैं, इसलिए हम समोच्च के माध्यम से प्रसंस्करण प्रौद्योगिकी पर अधिक विस्तार से विचार करें। OpenCV फ़ंक्शन

का उपयोग करके मौजूदा बाहरी सर्किट के अनुसार एक रेखापुंज उत्पन्न करने वाला रिवर्स ऑपरेशन भी सरल दिखता है:

 drawContours(mat, contours, -1, Scalar(255), -1);

यह भी अक्सर आकृति को मुखौटा बनाने, आकर्षित करने, या क्षेत्र की गणना करने के लिए उपयोग किया जाता है।

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

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

 contourTypeSearch(
   const vector<Point> &contour, Vec4i &def, RotatedRect &rc);

आयत की लंबाई और चौड़ाई का अनुपात रेखीय खंडों के साथ-साथ छोटे शोर आकृति के करीबियों को जल्दी से भेदभाव करने में मदद करता है । OpenCV

में घुमाए गए आयत में एक जटिल समन्वय प्रणाली है। यदि यह वह कोण नहीं है जिसकी आवश्यकता है, लेकिन इसके त्रिकोणमितीय कार्य , यह संदर्भ से सभी अधिक स्पष्ट है। यदि कोण के निरपेक्ष मान का उपयोग किया जाता है , तो यह ध्यान में रखा जाना चाहिए कि कोण क्षैतिज से आयत वामावर्त के पहले किनारे तक गिना जाता है और इसका नकारात्मक मान होता है । अण्डाकार आकृति के अंतिम बिंदु हमारी प्रक्रिया का उपयोग करते हुए पाए जाते हैं, जो चटाई रेखापुंज प्राप्त करता है

मास्किंग द्वारा मूल छवि से निकाली गई भेदभावपूर्ण रूपरेखा के साथ और अधिकतम दोष देता है :

 contourConvFeature(mat, &def, … );

इस फ़ंक्शन का मुख्य कोड दो OpenCV प्रक्रियाओं को कॉल करना है :

 vector<int> *hull = new vector<int>();
 convexHull(contour, *hull);
 vector<Vec4i> *defs = new vector<Vec4i>();
 convexityDefects(contour, *hull, *defs);

पहली प्रक्रिया में अध्ययन के तहत समोच्च के लिए एक उत्तल बहुभुज पाया जाता है , दूसरा - सभी उत्तल दोषों की गणना करता है ।

हम उत्तलता के संदर्भ में केवल सबसे बड़ा दोष लेते हैं , यह देखते हुए कि यह समोच्च के अंतिम बिंदुओं को निर्धारित करता है। यदि समोच्च की बाहरी या आंतरिक सीमाओं में विशेषताएं हैं तो यह मामला नहीं हो सकता है । उन्हें सुचारू करने के लिए , हम अध्ययन के तहत समोच्च के लिए अतिरिक्त चौरसाई लागू करते हैं (और संपूर्ण छवि के लिए नहीं ताकि समोच्च के बीच isthmuse को "धुंधला" न करें और मूल टोपोलॉजी का उल्लंघन न करें)।

चित्रा 4. उभार दोष की गणना।

विकल्प (ए) गलती से लाल समापन बिंदु को परिभाषित करता है। विकल्प (बी)सही ढंग से अंतिम बिंदु को परिभाषित करता है। विकल्प (सी) मूल आकृति पर समापन बिंदु को फिर से परिभाषित करता है।

चूंकि हमने जो तकनीक अपनाई है, उसमें सर्किट को हर बार पुनर्जीवित किया जाता है , हमें संपूर्ण खोज प्रक्रिया द्वारा पत्राचार (या बल्कि, उनके सूचकांक) के बिंदुओं को फिर से खोजना होगा :

 nearestContourPtIdx(const vector<Point> &contour, const Point& pt);

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

इसके अलावा, चाप की उत्तलता के अनुपात के लिए प्रसिद्ध सूत्र के अनुसार, वृत्त की त्रिज्या लगभग अनुमानित है और बहुत बड़े दीर्घवृत्ताकार खारिज कर दिए गए हैं:

R = bulge / 2 + SQR(hypot) / (8 * bulge);

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

 typedef tuple<int , // 
   RotatedRect, //  
   Vec4i, //  
   int> // 
   RectDefMetric;

अंतिम बिंदुओं पर चाप खंडों को जोड़ने के लिए एल्गोरिदम

विकास एल्गोरिथ्म स्पष्ट और स्पष्ट है: हम एक बीज के रूप में सबसे बड़ा समोच्च लेते हैं और इसे विकसित करने की कोशिश करते हैं, अर्थात्, निकटतम पैच को इसके अंत बिंदुओं से ढूंढते हैं और संलग्न करते हैं जो विकास की स्थिति को संतुष्ट करते हैं। बढ़ी हुई आकृति में, हम वांछित अण्डाकार चाप दर्ज करते हैं । मास्क और मूल सेट से आंकड़ा घटाना । हम विकास प्रक्रिया को तब तक दोहराते हैं जब तक कि शुरुआती सेट खत्म नहीं हो जाता ।

विकास एल्गोरिथम की मूल प्रक्रिया इस तरह दिखती है:

 vector<Point> *patch =
    growingContours(contour, def, tmp, hull);

जहां समोच्च अध्ययन के तहत समोच्च है, डीईएफ़ इसके उत्तलता दोष है, पतवार पूरे क्षेत्र का उत्तल बहुभुज है, tmp सहायक बफर मैट्रिक्स है। आउटपुट में, हमें एक वेक्टर बड़ा कंटूर मिलता है।

इस प्रक्रिया में बीज वृद्धि के प्रयासों का एक चक्र होता है, जो विकास के लिए उपलब्ध पैच को समाप्त करके या पुनरावृत्तियों की अधिकतम संख्या द्वारा सीमित होता है ।

चित्रा 5. बीज के बिना विकास के लिए कई पैच

मुख्य कठिनाई समोच्च के अंतिम बिंदुओं के लिए निकटतम पैच का चयन करना है , ताकि आंकड़ा केवल आगे बढ़ता है । के लिए स्पर्शरेखा दिशाहम एंडपॉइंट के आसपास के क्षेत्र में चाप से संबंधित औसत लाइन लेते हैं। में चित्रा 6 एक निश्चित यात्रा पर बीज के लिए कनेक्शन के लिए प्रदर्शित करता है उम्मीदवारों।

चित्रा 6. विकास प्रत्याशी पैच की बहुलता से घिरा बीज।

प्रत्येक उम्मीदवार पैच के लिए, निम्नलिखित मीट्रिक की गणना की जाती है:

typedef tuple<
   double, //    2      2   
   bool, bool, //,  4   
   int, // 
   Vec4i> //  
   DistMetric;

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

विकास प्रक्रिया के अंत में, हमें एक अण्डाकार चाप मिला , जिसे सत्यापित किया जाना बाकी है।

आरंभ करने के लिए, मानक OpenCV का उपयोग करवह प्रक्रिया जो हमारा पैच प्राप्त करता है (एक पथ के रूप में, हमें याद है कि पथ और रेखापुंज हमारे साथ विनिमेय हैं) और घुमाए गए आयाम , यानी एक पूर्ण दीर्घवृत्त लौटाता है।

 RotatedRect box = fitEllipse(patch);

फिर, हम बहुत बड़े और बहुत छोटे दीर्घवृत्त को अस्वीकार करते हैं, और फिर हम परिणामी अण्डाकार चाप के क्षेत्रों की तुलना करने और रेखापुंज में प्रारंभिक वृद्धि पैच के लिए हमारी मूल प्रक्रिया को लागू करते हैं । इस प्रक्रिया में कुछ प्रच्छन्न तरकीबें शामिल हैं, इसलिए हम अब इसके विवरण को छोड़ देंगे।

और अंत में, हम ज्ञात दीर्घवृत्त के शेष मापदंडों को पाते हैं - प्रारंभ और अंत कोण (हम पहले से ही फिट से आधे अक्ष को जानते हैं )।

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

 pair<int, int>
   ellipseAngles(const RotatedRect &box,
   vector<Point> &ell, const Point &ps, 
   const Point &pe, const Point &pm) 
 {
    vector<Point> ell0;
    ellipse2Poly(Point(box.center.x, box.center.y), 
      Size(box.size.width / 2, box.size.height / 2),
      box.angle, 0, 355, 5, ell0);
    int i0 = nearestContourPtIdx(ell0, ps);
    int i1 = nearestContourPtIdx(ell0, pe);
    cutSides(ell0, i0, i1, i2, ell, nullptr);
    return pair<int, int>(i0, i1);
}

हमारी कटसाइड्स प्रक्रिया अण्डाकार चाप ट्रैवर्सल टोपोलॉजी को ध्यान में रखती है । कुल मिलाकर, सूचकांकों i0, i1, i2 को दरकिनार करने के आठ संभावित मामलों पर विचार किया जाना चाहिए । क्या हम बाहरी समोच्च या आंतरिक एक के साथ जाते हैं, और कौन सा सूचक अधिक, प्रारंभिक या अंतिम है?

कोड देखने में आसान:

 void cutSides(
   const vector<Point> &ell0, int i0, int i1, int i2, 
   vector<Point> *ell_in, vector<Point> *ell_out)
 {
   if (i0 < i1) {
      if (i2 > i0 && i2 < i1) {
         if (ell_in) {...}
            if (ell_out) {...}
        } else {
            if (ell_in) {...}
            if (ell_out) {...}
        }}
    else {
        if (i2 > i1 && i2 < i0) {
            if (ell_in) {...}
            if (ell_out) {...}
        } else {
            if (ell_in) {...}
            if (ell_out) {...}
        }}}

जटिल मामलों में दीर्घवृत्त का पता लगाने के कुछ परिणाम चित्र 7 में दिखाए गए हैं ।

निम्नलिखित लेखों में, सांख्यिकीय पहचान विधियों पर विचार किया जाएगा।

3D बिंदु बादलों के 2D अनुभागों में अण्डाकार आर्क्स को पहचानने के लिए OpenCV लाइब्रेरी का उपयोग करना

अंतिम बिंदुओं पर चाप खंडों को जोड़ने के लिए एल्गोरिदम

More articles: