यह लेख कुछ खोज एल्गोरिदम और विशिष्ट छवि बिंदुओं के विवरण पर ध्यान केंद्रित करेगा। यहां यह विषय पहले ही उठाया जा चुका है, और एक से अधिक बार । मैं विचार करूंगा कि मूल परिभाषाएं पहले से ही पाठक के लिए परिचित हैं, हम विस्तार से जांच करेंगे एल्गोरिथ्म एल्गोरिथ्म फास्ट, फास्ट -9, फास्ट-ईआर, BRIEF, rBRIEF, ORB, और स्पार्कलिंग कि उन पर चर्चा करें। भाग में, यह कई लेखों के सार का मुफ्त अनुवाद होगा [1,2,3,4,5], "कोशिश" के लिए कुछ कोड होगा।

तेजी से एल्गोरिदम

FAST, जिसे पहली बार 2005 में [1] में प्रस्तावित किया गया था, एकवचन बिंदुओं को खोजने के लिए पहली अनुमानात्मक विधियों में से एक थी, जिसने इसकी कम्प्यूटेशनल दक्षता के कारण बहुत लोकप्रियता हासिल की। किसी दिए गए बिंदु C को विशेष मानें या नहीं, इस बारे में निर्णय लेने के लिए, यह विधि बिंदु C और त्रिज्या 3 पर केंद्रित वृत्त पर पिक्सेल की चमक पर विचार करती है:

केंद्र C की चमक के साथ सर्कल के पिक्सल की चमक की तुलना करें, प्रत्येक के लिए हमें तीन संभावित परिणाम मिलते हैं (हल्का, गहरा, ऐसा लगता है):

$ इनलाइन $ \ "{सरणी} {l} {I_p}> {I_C} + t \\ {I_p} <{I_C} -t \\ {I_C} -t <{I_p} </ I_C} + t \ end {array} $ इनलाइन $

यहाँ मैं पिक्सेल की चमक है, टी एक पूर्व निर्धारित चमक दहलीज है।
एक बिंदु को विशेष रूप से चिह्नित किया जाता है यदि पंक्ति में n = 12 पिक्सेल होते हैं जो गहरे रंग के होते हैं, या 12 पिक्सेल जो केंद्र की तुलना में हल्के होते हैं।

जैसा कि अभ्यास ने दिखाया है, औसतन, निर्णय लेने के लिए, लगभग 9 बिंदुओं की जांच करना आवश्यक था। इस प्रक्रिया को गति देने के लिए, लेखकों ने पहले केवल चार पिक्सेल की जाँच की संख्या: 1, 5, 9, 13. का सुझाव दिया। यदि उनमें से 3 पिक्सेल हल्का या गहरा है, तो 16 बिंदुओं पर पूर्ण जाँच की जाती है, अन्यथा, बिंदु को तुरंत "के रूप में चिह्नित किया जाता है। विशेष नहीं। ” यह काम करने के समय को बहुत कम कर देता है, औसतन एक निर्णय लेने के लिए यह केवल एक चक्र के लगभग 4 बिंदुओं को चुनने के लिए पर्याप्त है।

थोड़ा सा भोला कोड यहाँ निहित है
परिवर्तनीय पैरामीटर (कोड में वर्णित): सर्कल त्रिज्या (मान 1,2,3 लेता है), पैरामीटर एन (मूल, एन = 12), पैरामीटर टी। कोड .bmp फ़ाइल खोलता है, छवि को संसाधित करता है, इसे out.bmp में सहेजता है। चित्र साधारण 24-बिट हैं।

एक निर्णय पेड़, ट्री फास्ट, फास्ट -9 का निर्माण

2006 में, [2] में, मशीन लर्निंग और निर्णय पेड़ों का उपयोग करके एक मूल विचार विकसित करना संभव था।

मूल FAST के निम्नलिखित नुकसान हैं:

कई आसन्न पिक्सेल को विशेष बिंदुओं के रूप में चिह्नित किया जा सकता है। हमें एक विशेषता के "ताकत" के कुछ माप की आवश्यकता है। प्रस्तावित पहले उपायों में से एक टी का अधिकतम मूल्य है जिस पर बिंदु को अभी भी एक विशेष के रूप में लिया जाता है।
एक त्वरित 4-बिंदु परीक्षण 12 से कम n के लिए सामान्यीकृत नहीं है। इसलिए, उदाहरण के लिए, नेत्रहीन विधि के सर्वोत्तम परिणाम n = 9 के साथ प्राप्त किए जाते हैं, 12 नहीं।
मैं भी एल्गोरिथ्म को गति देना चाहूंगा!

4 और 16 बिंदुओं के दो परीक्षणों के कैस्केड का उपयोग करने के बजाय, यह निर्णय पेड़ के माध्यम से एक पास में सब कुछ करने का प्रस्ताव है। मूल विधि के समान, हम केंद्र बिंदु की चमक की तुलना चक्र के बिंदुओं के साथ करेंगे, लेकिन इस क्रम में निर्णय जल्द से जल्द करेंगे। और यह पता चला है कि आप औसतन केवल ~ 2 (!!!) की तुलना कर सकते हैं।

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

अब हम सर्कल के पिक्सेल पी में से एक को चुनते हैं और सभी एकवचन बिंदुओं के लिए हम चयनित वाले केंद्रीय पिक्सेल की तुलना करते हैं। प्रत्येक विशेष बिंदु के पास चयनित पिक्सेल की चमक के आधार पर, तालिका में निम्न परिणाम हो सकते हैं:

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

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

$$ प्रदर्शन $ $ H = \ left ({c + \ overline c} \ right) {\ log _2} \ left ({c + \ overline c} \ right) - c {\ log _2} c - \ overline c {\ __ _}} \ overline c $$ डिस्प्ले $$

c एकवचन बिंदुओं की संख्या है,

$ इनलाइन $ {\ bar c} $ इनलाइन $ सेट के गैर-विलक्षण बिंदुओं की संख्या है

बिंदु p के बाद एन्ट्रापी में परिवर्तन:

$ $ प्रदर्शन $$ \ Delta H = H - {H_ {dark}} - {H_ {बराबर}} - {H_ {Bright}} $ $ प्रदर्शन $ $

तदनुसार, एक बिंदु चुना जाता है जिसके लिए एन्ट्रापी में परिवर्तन अधिकतम होगा। एंट्रॉपी शून्य होने पर विभाजन की प्रक्रिया रुक जाती है, जिसका अर्थ है कि सभी बिंदु या तो एकवचन हैं, या इसके विपरीत - सभी विशेष नहीं हैं। एक सॉफ्टवेयर कार्यान्वयन के साथ, इस सब के बाद, पाया गया निर्णय ट्री "if-else" प्रकार के निर्माणों के एक सेट में परिवर्तित हो जाता है।

एल्गोरिथ्म का अंतिम चरण कई आसन्न बिंदुओं में से एक प्राप्त करने के लिए गैर-अधिकतम को दबाने का संचालन है। डेवलपर्स केंद्र बिंदु और इस रूप में सर्कल के बिंदुओं के बीच पूर्ण अंतर के योग के आधार पर मूल उपाय का उपयोग करने का सुझाव देते हैं:

$ $ $ $ $ V = \ max \ left ({\ _ \ limit_ {x \ _ S_ {Bright}}} {\ left।} {{I_x} - {I_p}} \ right | - t, \ sum \ _ लिमिट_ {x \ _ {S_ {Dark}}} {\ left | {{I_p} - {I_x}} \ right। - t}}} \ right) $ $ प्रदर्शन $ $

यहां

$ इनलाइन $ {S_ {उज्ज्वल}} $ इनलाइन $ और

$ इनलाइन $ {S_ {डार्क}} $ इनलाइन $ क्रमशः, पिक्सेल के समूह हल्के और गहरे होते हैं, टी थ्रेशोल्ड ब्राइटनेस मान है,

$ इनलाइन $ {I_p} $ इनलाइन $ - केंद्रीय पिक्सेल की चमक,

$ इनलाइन $ {{I_x}} $ इनलाइन $ - सर्कल पर पिक्सेल की चमक। आप निम्न कोड के साथ एल्गोरिथ्म की कोशिश कर सकते हैं। कोड OpenCV से लिया गया है और सभी निर्भरताओं से मुक्त किया गया है, बस इसे चलाएं।

निर्णय पेड़ का अनुकूलन - फास्ट-ईआर

फास्ट-ईआर [3] पिछले एक के रूप में एक ही लेखक का एक एल्गोरिथ्म है, एक फास्ट डिटेक्टर इसी तरह का निर्माण किया जाता है, अंकों का इष्टतम अनुक्रम तुलना के लिए भी खोजा जाता है, एक निर्णय ट्री भी बनाया जाता है, लेकिन एक अलग विधि का उपयोग करके - अनुकूलन विधि।

हम पहले से ही समझते हैं कि एक डिटेक्टर को एक निर्णय पेड़ के रूप में दर्शाया जा सकता है। यदि हमारे पास विभिन्न पेड़ों के प्रदर्शन की तुलना करने के लिए कोई मापदंड है, तो हम पेड़ों के विभिन्न प्रकारों के माध्यम से छंटनी करके इस मानदंड को अधिकतम कर सकते हैं। और इस तरह की कसौटी के रूप में, "पुनरावृत्ति" का उपयोग करने का प्रस्ताव है।

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

$ $ प्रदर्शन $ $ R = \ frac {{{N_ {दोहराया}}}} {{{N_ {उपयोगी}}}} $ $ प्रदर्शन $ $

सबसे अच्छा डिटेक्टर खोजने के लिए, एक एनीलिंग सिमुलेशन विधि का उपयोग किया जाता है। उसके बारे में Habré पर पहले से ही एक उत्कृष्ट लेख है। संक्षेप में, विधि का सार इस प्रकार है:

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

इसके अलावा, डिटेक्टर के निर्माण में अब सर्कल के 16 अंक शामिल नहीं हैं, पहले की तरह 47, लेकिन अर्थ बिल्कुल नहीं बदलता है:

नकली एनालिंग विधि के अनुसार, हम तीन कार्यों को परिभाषित करते हैं:

• लागत समारोह कश्मीर। हमारे मामले में, हम मूल्य के रूप में दोहराव का उपयोग करते हैं। लेकिन एक समस्या है। कल्पना कीजिए कि दोनों छवियों में से प्रत्येक पर सभी बिंदुओं को एकवचन के रूप में पाया जाता है। फिर यह पता चलता है कि दोहराव 100% है - बेतुकापन। दूसरी ओर, भले ही हमें दो चित्रों में एक विशेष बिंदु मिला हो, और ये अंक मेल खाते हैं - दोहराव भी 100% है, लेकिन यह भी हमें दिलचस्पी नहीं देता है। और इसलिए, लेखकों ने इसे एक गुणवत्ता मानदंड के रूप में उपयोग करने का प्रस्ताव दिया:

$$ प्रदर्शन $ $ k = \ left ({1 + {{बाएँ ({\ _ frac {{w_r}}} {R}} \ right)} ^ 2}} \ right) \ बाएँ ({1 + \ _) frac {1} {N} \ sum \ limit_ {i = 1} {{\ _ left ({\ _ frac {{d_i}}} {{{w_n}}}}})} 2}}} \ _ दायां) \ बायां ({1 + {{बाएं} ({\ _ frac {s} {{{w_s}}}}})}} 2}} \ right) $ $ प्रदर्शन $ $

आर दोहराव है

$ इनलाइन $ {{d_i}} $ इनलाइन $ फ़्रेम पर पता लगाए गए कोणों की संख्या i, N फ़्रेम की संख्या है, और s पेड़ का आकार (संख्याओं की संख्या) है। डब्ल्यू कस्टम विधि पैरामीटर हैं।]

समय के साथ तापमान परिवर्तन का कार्य:

$ $ प्रदर्शन $ $ T \ left (I \ right) = \ Beta \ exp \ left ({- \ frac {{\ Alpha I}}} {{I_ {\ max}}} \ right) $$ प्रदर्शन $$

जहाँ

$ इनलाइन $ \ अल्फा, \ बीटा $ इनलाइन $ गुणांक हैं, इमैक्स पुनरावृत्तियों की संख्या है।

• एक फ़ंक्शन जो एक नया समाधान उत्पन्न करता है। एल्गोरिथ्म पेड़ को यादृच्छिक संशोधन करता है। सबसे पहले, कुछ शीर्ष चुनें। यदि चयनित शीर्ष एक पेड़ का एक पत्ता है, तो समान संभावना के साथ हम निम्नलिखित कार्य करते हैं:

गहराई 1 के साथ यादृच्छिक उपशीर्षक के साथ शीर्ष को बदलें
इस शीट की कक्षा बदलें (एकवचन-निरंकुश अंक)

यदि यह एक पत्रक नहीं है:

0 से 47 तक यादृच्छिक संख्या के साथ परीक्षण बिंदु की संख्या को बदलें
एक यादृच्छिक वर्ग के साथ शीट के साथ वर्टेक्स बदलें
इस शीर्ष से दो उपप्रकार स्वैप करें

I पर परिवर्तन को स्वीकार करने की संभावना P है:

$ इनलाइन $ P = \ exp \ left ({\ frac {{k \ left ({i - 1} \ right) - k \ left (i \ right)}} {T}} \ right) $ इनलाइन $
k लागत फ़ंक्शन है, T तापमान है, मैं पुनरावृत्ति संख्या है।

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

संक्षिप्त विवरण

एकवचन बिंदु पाए जाने के बाद, उनके विवरणों की गणना की जाती है, अर्थात प्रत्येक एकवचन बिंदु के पड़ोस को दर्शाने वाली विशेषताओं का समूह। BRIEF [4] एक तेज़ हेयोरिस्टिक डिस्क्रिप्टर है, जो धुंधली छवि में पिक्सेल की चमक के बीच 256 बाइनरी तुलनाओं से निर्मित है। अंक x और y के बीच द्विआधारी परीक्षण निम्नानुसार परिभाषित किया गया है:

$ $ $ $ $ \ _ \ _ ताऊ ({P, x, y} \ सही) प्रदर्शित करें: = \ बायां \ {{\ _ शुरू {सरणी} {* {20} {c}} {1: p \ left (x \) दाएँ) <p \ left (y \ right)} \\ {0: p \ left (x \ right) \ ge p \ बाएँ (y \ दाएँ)} \ end {सरणी}} \ right। $ $ $ $ प्रदर्शित।

मूल लेख में, बाइनरी तुलना के लिए अंक चुनने के कई तरीकों पर विचार किया गया था। जैसा कि यह निकला, सबसे अच्छा तरीकों में से एक केंद्रीय पिक्सेल के आसपास एक गाऊसी वितरण का उपयोग करके यादृच्छिक रूप से बिंदुओं का चयन करना है। अंकों का यह यादृच्छिक क्रम एक बार चुना जाता है और आगे नहीं बदलता है। बिंदु के माना पड़ोस का आकार 31x31 पिक्सेल है, और धब्बा एपर्चर 5 है।

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

ओआरबी - तेज और कुशल

इन सभी विचारों का विकास ORB (ओरिएंटेड फास्ट एंड रोटेटेड BRIEF) एल्गोरिथ्म [5] था, जिसमें छवि रोटेशन के दौरान BRIEF प्रदर्शन को बेहतर बनाने का प्रयास किया गया था। यह पहले एकवचन बिंदु के अभिविन्यास की गणना करने और फिर इस अभिविन्यास के अनुसार द्विआधारी तुलना का संचालन करने का प्रस्ताव है। एल्गोरिथ्म इस तरह काम करता है:

1) फ़ीचर पॉइंट्स का पता मूल छवि में तेज़ FAST ट्री का उपयोग करके और थंबनेल पिरामिड से कई छवियों में लगाया गया है।

2) पाए गए बिंदुओं के लिए, हैरिस माप की गणना की जाती है, हैरिस माप के कम मूल्य वाले उम्मीदवारों को छोड़ दिया जाता है।

3) एकवचन बिंदु के अभिविन्यास कोण की गणना की जाती है। इसके लिए, एकवचन बिंदु के पड़ोस के चमक क्षणों की गणना पहले की जाती है:

$ इनलाइन $ {m_ {pq}} = \ sum \ limit_ {x, y} {{x ^ p} {y ^ q} I \ left ({x, y} \ right)} $ इनलाइन $
x, y - पिक्सेल निर्देशांक, I - चमक। और फिर एकवचन बिंदु का अभिविन्यास कोण:

$ इनलाइन $ \ थीटा = {\ rm {atan2}} \ left ({{m_ {01}}, {m_ {10}}} \ right) $ इनलाइन $

यह सब, लेखकों ने "सेंट्रोइड ओरिएंटेशन" कहा। नतीजतन, हम एकवचन बिंदु के पड़ोस के लिए एक निश्चित दिशा प्राप्त करते हैं।

4) एकवचन बिंदु के अभिविन्यास कोण के बाद, BRIEF विवरणक में द्विआधारी तुलना के लिए बिंदुओं का क्रम इस कोण के अनुसार घूमता है, उदाहरण के लिए:

औपचारिक रूप से, बाइनरी टेस्ट पॉइंट के लिए नए पदों की गणना निम्न प्रकार से की जाती है:

$ $ प्रदर्शन $ $ \ बायाँ ({\ start {array} {* {20} {c}} {{x_i} ’}} \\ {{y_i}’} \ end {array}} \ right) = R \ left ((ata \ right) \ cdot \ बाएँ ({\ start {array} {* 20} {c}} {{x_i}} \\ {{y_i}} \ end {array}} \ right) $$ डिस्प्ले $$

5) प्राप्त बिंदुओं के आधार पर, BRIEF द्विआधारी विवरणक की गणना की जाती है

और वह ... सभी नहीं! ओआरबी में एक और दिलचस्प विवरण है जिसके लिए अलग से स्पष्टीकरण की आवश्यकता है। तथ्य यह है कि इस समय जब हम सभी एकवचन बिंदुओं को शून्य कोण पर "मोड़" देते हैं, तो विवरणक में बाइनरी तुलना की यादृच्छिक पसंद यादृच्छिक होना बंद हो जाती है। यह इस तथ्य की ओर जाता है कि, सबसे पहले, कुछ बाइनरी तुलनाएं एक दूसरे पर निर्भर होने के लिए निकलती हैं, और दूसरी बात, उनका औसत अब 0.5 के बराबर नहीं है (1 हल्का है, 0 गहरा है जब चुनाव यादृच्छिक था, तो औसत 0.5 था) यह सब महत्वपूर्ण रूप से वर्णनात्मक की क्षमता को कम कर देता है ताकि आपस में विलक्षण बिंदुओं को अलग किया जा सके।

समाधान - आपको सीखने की प्रक्रिया में "सही" बाइनरी परीक्षणों का चयन करने की आवश्यकता है, यह विचार FAST-9 एल्गोरिथ्म के लिए वृक्ष प्रशिक्षण के समान स्वाद को उड़ा देता है। मान लीजिए कि हमारे पास पहले से पाए गए विलक्षण बिंदुओं का एक समूह है। बाइनरी टेस्ट के लिए सभी संभावित विकल्पों पर विचार करें। यदि पड़ोस 31 x 31 है, और बाइनरी टेस्ट 5 x 5 सबसेट (धुंधला होने के कारण) की एक जोड़ी है, तो एन = (31-5) ^ 2 चुनने के लिए बहुत सारे विकल्प हैं। "अच्छे" परीक्षणों के लिए खोज एल्गोरिथ्म इस प्रकार है:

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

यह पता चला है कि परीक्षणों का चयन इसलिए किया जाता है, ताकि एक ओर, इन परीक्षणों का औसत मान 0.5 के करीब हो, दूसरी ओर, ताकि विभिन्न परीक्षणों के बीच संबंध न्यूनतम हो। और यही हमें चाहिए। तुलना करें कि यह कैसा था और यह कैसे बन गया:

सौभाग्य से, ORB एल्गोरिथ्म को CC :: ORB वर्ग में OpenCV लाइब्रेरी में लागू किया गया है। मैं 2.4.13 संस्करण का उपयोग कर रहा हूं। वर्ग निर्माता निम्नलिखित मापदंडों को स्वीकार करता है:

nfeatures - एकवचन बिंदुओं की अधिकतम संख्या
स्केलफ़ेक्टर - छवियों के पिरामिड के लिए गुणक, एक से अधिक। मूल्य 2 क्लासिक पिरामिड को लागू करता है।
nlevels - छवियों के पिरामिड में स्तरों की संख्या।
एजट्रेशोल्ड - छवि की सीमा पर पिक्सेल की संख्या जहां एकवचन बिंदुओं का पता नहीं लगाया जाता है।
FirstLevel - शून्य छोड़ दें।
WTA_K - वर्णक के एक तत्व के लिए आवश्यक अंकों की संख्या। यदि 2 के बराबर है, तो दो बेतरतीब ढंग से चयनित पिक्सेल की चमक की तुलना की जाती है। इसकी जरूरत है।
स्कोर टाइप - यदि 0, तो हैरिस का उपयोग एक फीचर माप के रूप में किया जाता है, अन्यथा - सबसे तेज़ माप (सर्कल के बिंदुओं पर चमक अंतर के योग के आधार पर)। फास्ट माप थोड़ा कम स्थिर है, लेकिन तेज है।
पैचसाइज़ - पड़ोस का आकार जिसमें से यादृच्छिक पिक्सेल तुलना के लिए चुने गए हैं। कोड दो चित्रों, "templ.bmp" और "img.bmp" में एकवचन बिंदुओं की खोज और तुलना करता है

कोड

cv::Mat img_object=cv::imread("templ.bmp", 0); std::vector<cv::KeyPoint> keypoints_object, keypoints_scene; cv::Mat descriptors_object, descriptors_scene; cv::ORB orb(500, 1.2, 4, 31, 0, 2, 0, 31); //    orb.detect(img_object, keypoints_object); orb.compute(img_object, keypoints_object, descriptors_object); //    cv::Mat img = cv::imread("img.bmp", 1); cv::Mat img_scene = cv::Mat(img.size(), CV_8UC1); orb.detect(img, keypoints_scene); orb.compute(img, keypoints_scene, descriptors_scene); cv::imshow("desrs", descriptors_scene); cvWaitKey(); int test[10]; for (int q = 0; q<10 ; q++) test[q]=descriptors_scene.data[q]; //-- matching descriptor vectors using FLANN matcher cv::BFMatcher matcher; std::vector<cv::DMatch> matches; cv::Mat img_matches; if(!descriptors_object.empty() && !descriptors_scene.empty()) { matcher.match (descriptors_object, descriptors_scene, matches); double max_dist = 0; double min_dist = 100; // calculation of max and min idstance between keypoints for( int i = 0; i < descriptors_object.rows; i++) { double dist = matches[i].distance; if( dist < min_dist ) min_dist = dist; if( dist > max_dist ) max_dist = dist; } //-- Draw only good matches (ie whose distance is less than 3*min_dist) std::vector< cv::DMatch >good_matches; for( int i = 0; i < descriptors_object.rows; i++ ) if( matches[i].distance < (max_dist/1.6) ) good_matches.push_back(matches[i]); cv::drawMatches(img_object, keypoints_object, img_scene, keypoints_scene, good_matches, img_matches, cv::Scalar::all(-1), cv::Scalar::all(-1), std::vector<char>(), cv::DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS); } cv::imshow("match result", img_matches ); cv::waitKey(); return 0;

यदि किसी ने एल्गोरिदम के सार को समझने में मदद की, तो यह व्यर्थ नहीं है। सभी हबर को।

संदर्भ:

1. उच्च प्रदर्शन ट्रैकिंग के लिए फ़्यूज़िंग पॉइंट और लाइन्स
2. उच्च गति कोने का पता लगाने के लिए मशीन सीखने
3. तेज़ और बेहतर: कोने का पता लगाने के लिए एक मशीन सीखने का दृष्टिकोण
4. BRIEF: बाइनरी रोबस्ट इंडिपेंडेंट एलिमेंटरी फीचर्स
5. ORB: SIFT या SURF के लिए एक वैकल्पिक विकल्प

डिटेक्टर और विलक्षण बिंदुओं के वर्णनकर्ता FAST, BRIEF, ORB

तेजी से एल्गोरिदम

एक निर्णय पेड़, ट्री फास्ट, फास्ट -9 का निर्माण

निर्णय पेड़ का अनुकूलन - फास्ट-ईआर

संक्षिप्त विवरण

ओआरबी - तेज और कुशल

More articles: