OpenCV 2.4 फ्लैट ऑब्जेक्ट मान्यता

सभी को नमस्कार। मैं OpenCV का उपयोग करके ऑब्जेक्ट की मान्यता अंतर्निहित सिद्धांतों के बारे में बात करना चाहूंगा। सौभाग्य से, कुछ समय के लिए मुझे VMK मास्को स्टेट यूनिवर्सिटी में कंप्यूटर विज़न की प्रयोगशाला में काम करने का अवसर मिला, और मैं कंप्यूटर विज्ञान की इस शाखा के ज्ञान में थोड़ा घुस गया। कार्य, जिसे मैं यहां पर विचार करूंगा, ओपनकॉव सॉफ्टवेयर पैकेज के डेवलपर्स में से एक विक्टर इरुखिमोव की संगोष्ठी में माइक्रोसॉफ्ट कंप्यूटर विजन स्कूल मास्को 2011 में प्रस्तावित किया गया था। लगभग उसी रूप में, प्रश्न में कोड OpenCV 2.4 डेमो में पाया जा सकता है।

कार्य की औपचारिकता

हम निम्नलिखित कार्य निर्धारित करते हैं: एक नियमित यूएसबी कैमरा से दृश्य की छवि और लक्ष्य फ्लैट ऑब्जेक्ट की छवि (जैसे पुस्तक) इनपुट हैं। कार्य दृश्य छवि में लक्ष्य वस्तु ढूंढना है।

चलो कैमरे से शुरू करते हैं

सबसे पहले, हम h. core.hpp और opencv.hpp फाइलें शामिल करते हैं, जो opencv और features2d.hpp बेस कक्षाओं के लिए जिम्मेदार हैं, जो विभिन्न डिटेक्टरों और डिस्क्रिप्टर (हम SURF में रुचि रखते हैं) की कक्षाओं को परिभाषित करते हैं।

#include <iostream> #include "opencv2/opencv.hpp" #include "opencv2/core/core.hpp" #include "opencv2/nonfree/features2d.hpp" #include <vector> using namespace std; using namespace cv; void readme(string &message) { cout << message << endl; } 

अगला, मुख्य निकाय शुरू होता है, हम मानते हैं कि हम निष्पादन योग्य फ़ाइल में 1 पैरामीटर पास करते हैं, नमूना (फ्लैट ऑब्जेक्ट) की तस्वीर का मार्ग। VideoCapture क्लास का कंस्ट्रक्टर डिवाइस की संख्या (कैमरा) को इनपुट के रूप में स्वीकार करता है, 0 - डिफॉल्ट डिवाइस (शायद बिल्ट-इन कैमरा)। इसके बाद, लक्ष्य छवि img_object में पढ़ी जाती है।

 int main( int argc, char** argv ) { if(argc != 2) { string message = ": ./cv_test <img_object>"; readme(message); return -1; } VideoCapture cap(1); //   ( 1).      0 . if(!cap.isOpened()) //    { string message = "        "; readme(message); return -1; } Mat img_object = imread( argv[1], CV_LOAD_IMAGE_GRAYSCALE ); 

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

 for(;;) { Mat frame; cap >> frame; //      Mat img_scene = frame; if( !img_object.data || !img_scene.data ) //       { string message = "   "; readme(message); } 

कुंजी अंक ढूँढना

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

अर्थ यह है कि मेट्रिक का उपयोग किया जाता है (लैम्ब्डा ईजेनवेल्यूज़ हैं, det एक निर्धारक है, ट्रेस मैट्रिक्स का एक ट्रेस है, अल्फा एक स्थिरांक है)

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

 //--  1.   . int minHessian = 400; SurfFeatureDetector detector( minHessian ); std::vector<KeyPoint> keypoints_object, keypoints_scene; detector.detect( img_object, keypoints_object ); detector.detect( img_scene, keypoints_scene ); 

डिस्क्रिप्टर्स का पता लगाना

अगला, आपको एक विवरणक की गणना करने की आवश्यकता है, - एक वेक्टर एक बिंदु के आसपास एक स्थानीय पड़ोस की ज्यामिति को एन्कोडिंग। यह आमतौर पर SIFT (SURF एक तेज SIFT है) पर आधारित है। यहाँ सिद्धांत इस प्रकार है:


इस बिंदु के चारों ओर के पैच को नियतात्मक ब्लॉकों में विभाजित किया जाता है, प्रत्येक ब्लॉक में प्रमुख ढाल दिशा की गणना की जाती है और परिमाण + को प्रमुख दिशा की ओर घुमाया जाता है (रोटेशन के लिए विपरीत)। यह "ढाल पैटर्न" एक स्थानीय पैच का वर्णन करता है।

 //--  2.  . SurfDescriptorExtractor extractor; Mat descriptors_object, descriptors_scene; extractor.compute( img_object, keypoints_object, descriptors_object ); extractor.compute( img_scene, keypoints_scene, descriptors_scene ); 

वर्णनात्मक तुलना

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

 //--  3:    . FlannBasedMatcher matcher; vector< DMatch > matches; matcher.match( descriptors_object, descriptors_scene, matches ); double max_dist = 0; double min_dist = 100; //--         //    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; } printf("-- Max dist : %f \n", max_dist ); printf("-- Min dist : %f \n", min_dist ); //--    ,    3 * min_dist vector< DMatch > good_matches; for( int i = 0; i < descriptors_object.rows; i++ ) { if( matches[i].distance < 3 * min_dist ) { good_matches.push_back( matches[i]); } } Mat img_matches; //--    drawMatches( img_object, keypoints_object, img_scene, keypoints_scene, good_matches, img_matches, Scalar::all(-1), Scalar::all(-1), vector<char>(), DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS ); 

होमोग्राफी का उपयोग करना

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

  //--   vector<Point2f> obj; vector<Point2f> scene; for( int i = 0; i < good_matches.size(); i++ ) { obj.push_back( keypoints_object[ good_matches[i].queryIdx ].pt ); scene.push_back( keypoints_scene[ good_matches[i].trainIdx ].pt ); } Mat H = findHomography( obj, scene, CV_RANSAC ); 

अगला, आपको लक्ष्य ऑब्जेक्ट के किनारों के साथ 4 अंक लेने की जरूरत है और उन्हें दृश्य छवि पर पाए गए परिवर्तन का उपयोग करके प्रदर्शित करना है। इस प्रकार, हम दृश्य में ऑब्जेक्ट की बाउंडिंग बॉक्स पाएंगे। ध्यान दें कि जब रेखाएँ खींचती हैं, तो हम प्रत्येक बिंदु पर Point2f (img_object.cols, 0) जोड़ते हैं, क्योंकि Img_matches छवि लक्ष्य छवि (बाएं) और दृश्य (दाएं) के आसन्न प्लेसमेंट को मानती है।

 //--  ""     std::vector<Point2f> obj_corners(4); obj_corners[0] = cvPoint(0,0); obj_corners[1] = cvPoint( img_object.cols, 0 ); obj_corners[2] = cvPoint( img_object.cols, img_object.rows ); obj_corners[3] = cvPoint( 0, img_object.rows ); std::vector<Point2f> scene_corners(4); //--    ,   ,   perspectiveTransform( obj_corners, scene_corners, H); //--    line( img_matches, scene_corners[0] + Point2f( img_object.cols, 0), scene_corners[1] + Point2f( img_object.cols, 0), Scalar(0, 255, 0), 4 ); line( img_matches, scene_corners[1] + Point2f( img_object.cols, 0), scene_corners[2] + Point2f( img_object.cols, 0), Scalar( 0, 255, 0), 4 ); line( img_matches, scene_corners[2] + Point2f( img_object.cols, 0), scene_corners[3] + Point2f( img_object.cols, 0), Scalar( 0, 255, 0), 4 ); line( img_matches, scene_corners[3] + Point2f( img_object.cols, 0), scene_corners[0] + Point2f( img_object.cols, 0), Scalar( 0, 255, 0), 4 ); //-- Show detected matches imshow( "Good Matches & Object detection", img_matches ); if(waitKey(30) >= 0) break; } //--     

सारांश

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

साहित्य

1. www.vision.ee.ethz.ch/~surf/eccv06.pdf
2. www.sci.utah.edu/~gerig/CS6640-F2010/tutorial2-homographies.pdf
3. Engineering.purdue.edu/kak/courses-i-teach/ECE661.08/solution/hw4_s1.pdf