2D-> संवर्धित वास्तविकता में 3 डी

इस लेख में, मैं आपको बताऊंगा कि किसी दृश्य में किसी वस्तु के पाए गए स्थान का उपयोग करके संवर्धित वास्तविकता अनुप्रयोगों में 3D स्थान कैसे बनाया जाए। ऐसा करने के लिए, आपको काम के लिए दो मेट्रिसेस - प्रोजेक्शन (GL_PROJECTION) और मॉडल (GL_MODELVIEW) प्राप्त करने की आवश्यकता है, उदाहरण के लिए, ओपनजीएल में। हम OpenCV लाइब्रेरी का उपयोग करके ऐसा करेंगे।

हाल ही में मुझे इस समस्या को हल करना था, लेकिन मुझे ऐसा संसाधन नहीं मिला जहां यह सिर्फ चरणों में समझाया जाए कि यह कैसे करना है (शायद मैं बुरी तरह से देख रहा था), लेकिन इस समस्या में पर्याप्त नुकसान हैं। किसी भी मामले में, इस कार्य का वर्णन करने वाले हब पर एक लेख चोट नहीं पहुंचाएगा।

प्रविष्टि

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

सामान्य तौर पर, इस क्षेत्र में मोबाइल उपकरणों (iOS / Android) के लिए सबसे दिलचस्प प्रस्ताव क्वालकॉम का विकास है।

हाल ही में, उन्होंने अपने खुद के एआर एसडीके को वुफोरिया नाम से जारी किया । उसी समय, SDK का उपयोग विकास के लिए और स्टोर में एप्लिकेशन (AppStore, AndroidMarket) में डालने के लिए स्वतंत्र है, लाइसेंसिंग पैराग्राफ को गर्व के साथ बताता है। इसी समय, वे लिखते हैं कि आपको अंतिम उपयोगकर्ता को चेतावनी देनी चाहिए कि यह एसडीके कुछ अनाम जानकारी एकत्र कर सकता है और इसे क्वालकॉम सर्वरों को भेज सकता है। आप इस लिंक को राइट मेनू में मिल रहे स्टार्टिंग एसडीके -> स्टेप 3: कंपाइलिंग एंड रनिंग ... -> पब्लिश योर एप्लीकेशन पर क्लिक करके इस सेक्शन को पा सकते हैं। और इसके अलावा, आप मुझे पागल मान सकते हैं, लेकिन मुझे 90% यकीन है कि जब उनकी एसडीके लोकप्रियता का एक निश्चित प्रतिशत हासिल करेगी, तो वे कहेंगे "यही है, फ्रीबी खत्म हो गई है, दादी का भुगतान करें"।

इसलिए, मुझे लगता है कि मेरे अपने इंजन का विकास समय की बर्बादी नहीं है।

असल में, बात करने के लिए!

सिद्धांत

हम मानते हैं कि इस बिंदु पर आपने अपने प्रोजेक्ट में OpenCV ( कैसे? ) लागू किया है, और पहले ही कैमरे से आने वाले फ्रेम में किसी वस्तु को पहचानने के लिए एक विधि लिखी है। अर्थात्, आपके पास कुछ इस तरह है:



इस विषय पर एक सिद्धांत कई स्रोतों में पाया जा सकता है। मैंने नीचे मुख्य लिंक दिए हैं। प्रारंभिक संसाधन OpenCV प्रलेखन पृष्ठ है, हालांकि कई पढ़ने के सवाल हैं।

संक्षेप में, 2 डी होमोग्राफी से 3 डी स्पेस बनाने के लिए, हमें 2 मैट्रिसेस को जानना होगा:

• आंतरिक मैट्रिक्स (आंतरिक मैट्रिक्स), या कैमरा मैट्रिक्स - इस मैट्रिक्स में कैमरा पैरामीटर होते हैं - फोकल दूरी दो अक्षों ( fx , fy ) और फोकस केंद्र समन्वय ( cx , cy ) के साथ।
  इस मैट्रिक्स की संरचना:
  
  
• एक बाहरी मैट्रिक्स, या मॉडल मैट्रिक्स, मॉडल का खिंचाव, घूमना और परिवहन मैट्रिक्स है। यह, वास्तव में, विशिष्ट रूप से अंतरिक्ष में वस्तु की स्थिति निर्धारित करता है। संरचना:
  ।
  जहां विकर्ण तत्व खींच के लिए जिम्मेदार हैं, शेष तत्व रोटेशन के लिए आर , और परिवहन के लिए तत्व हैं।
  नोट: सामान्य तौर पर, इस मैट्रिक्स की संरचना मॉडल (समन्वय परिवर्तन समीकरणों) के आधार पर भिन्न हो सकती है। उदाहरण के लिए, उसी OpenGL में, थोड़ी अलग संरचना का एक मैट्रिक्स प्रेषित होता है, लेकिन प्रमुख तत्व हमेशा इसमें मौजूद होते हैं।
  

अभ्यास

अभ्यास में, OpenGL के लिए हमारी वस्तु के शीर्ष पर एक 3D मॉडल प्रस्तुत करने के लिए, हमें इसे सेट करने की आवश्यकता है:

• प्रक्षेपण मैट्रिक्स GL_PROJECTION है।
• मॉडल मैट्रिक्स GL_MODELVIEW है।

नोट: iOS में, आप OpenGLES के 1.1 और 2.0 संस्करण का उपयोग कर सकते हैं। मुख्य अंतर दूसरे संस्करण में शेडर्स की उपस्थिति है। दोनों मामलों में, हमें 2 मेट्रिसेस निर्दिष्ट करने होंगे, केवल पहले मामले में वे प्रकार के निर्माण से परिभाषित होते हैं:

glMatrixMode(GL_PROJECTION); glLoadMatrixf(projectionMatrix); glMatrixMode(GL_MODELVIEW); glLoadMatrixf(modelViewMatrix); 

और दूसरे में, आप उन्हें shaders के इनपुट में पास करते हैं।

अगला, हम यह निर्धारित करेंगे कि आपके द्वारा कैमरे से प्राप्त फ्रेम का आकार कैमरासाइज़ = (चौड़ाई, ऊंचाई) है। मेरे मामले में, कैमरासाइज़ = (640, 480)।

आइए जानें कि प्रत्येक मैट्रिक्स का निर्माण कैसे करें।

प्रोजेक्शन मैट्रिक्स

यह मैट्रिक्स कैमरा मैट्रिक्स पर आधारित है। जैसा कि ऊपर दिखाया गया है, बाद वाले में कुछ निश्चित कैमरा पैरामीटर होते हैं। सिद्धांत रूप में, इन मापदंडों की गणना कैमरे की तकनीकी विशेषताओं के आधार पर की जा सकती है, लेकिन व्यवहार में कोई भी नहीं करता है।

कैमरा पैरामीटर खोजने की प्रक्रिया को इसका अंशांकन कहा जाता है। OpenCV में अंशांकन प्रदर्शन के लिए सभी आवश्यक कार्य शामिल हैं। इसके अलावा, एक उदाहरण है जो आपको अपने वेबकैम को ऑनलाइन जांचने की अनुमति देता है। लेकिन हमें डिवाइस पर कैमरे को कैलिब्रेट करने की आवश्यकता है - iPhone / iPad / iPod। और यहाँ मैं बताए गए रास्ते पर चला गया।

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

• A4 शीट पर एक चेकरबोर्ड टेम्पलेट प्रिंट करें। शीट साफ होनी चाहिए, यह बहुत ही वांछनीय है कि प्रिंटर "प्रवाह" नहीं करता है।
  
• यह सुनिश्चित करने की कोशिश करें कि तस्वीरों में शतरंज की शीट सतह पर बिल्कुल बिछी हो - किनारों को मुड़ा हुआ नहीं था, शीट के किसी भी मोड़ अनुपस्थित थे। ऐसा करने के लिए, आप इसे कार्डबोर्ड पर चिपका सकते हैं, या बस किनारों पर भारी वस्तुओं को रख सकते हैं, लेकिन ताकि वे टेम्पलेट के रूप को अवरुद्ध न करें।
  
• कैमरे से चित्रों को कैमरा आकार में परिवर्तित किया जाना चाहिए। यह एक स्पष्ट कदम नहीं है - उदाहरण के लिए, iPhone 4 पर, जब मैं इसे पहचानता हूं, तो मैं कैमरे के फ्रेम आकार का उपयोग करता हूं 640x480, और जब आप एक साधारण कैमरा के साथ एक तस्वीर लेते हैं और इसे कंप्यूटर पर छोड़ते हैं - आपको बड़ी तस्वीरें मिलती हैं (2592x2536), मैंने उन्हें 640x480 को संकुचित कर दिया, और मैंने कार्यक्रम में इनका उपयोग किया।
  
• विभिन्न कोणों से टेम्पलेट के शॉट्स की संख्या 12-16 + होनी चाहिए। व्यक्तिगत रूप से, मैंने 12 और 16 पर बनाए गए मापदंडों को बदलते हुए, 16 शॉट्स का इस्तेमाल किया, हालाँकि यह बड़ा नहीं है। सामान्य तौर पर, अधिक छवियां, पैरामीटर जितना सटीक होता है, और यह सटीकता 3D ऑब्जेक्ट्स का निर्माण करते समय शिफ्ट की उपस्थिति / अनुपस्थिति को और अधिक प्रभावित करेगी।
  
• कैमरा मैट्रिक्स के अलावा, इस स्तर पर हम विरूपण गुणांक पाते हैं। संक्षेप में, ये गुणांक कैमरे के लेंस द्वारा छवि के विरूपण का वर्णन करते हैं। आप OpenCV प्रलेखन और विकिपीडिया पर अधिक पढ़ सकते हैं। मोबाइल उपकरणों के लिए, अधिकांश कैमरों में उच्च गुणवत्ता वाले कैमरे होते हैं, और ये अनुपात अपेक्षाकृत छोटे होते हैं, इसलिए आप उन्हें अनदेखा कर सकते हैं।
  

Xcode प्रोजेक्ट कैलिब्रेशन प्रोग्राम जिसे आप यहाँ डाउनलोड कर सकते हैं । इस मामले में, आपने OpenCV संकलित किया होगा। या आप यहां से संकलित रूपरेखा डाउनलोड कर सकते हैं ।
तस्वीरें खुद, आपको संकलित बाइनरी के साथ फ़ोल्डर में डालने की जरूरत है, और क्रम में नाम बदलें।
यदि सब कुछ ठीक है, तो आपको प्रोग्राम आउटपुट में 2 फाइलें मिलेंगी:

• Intrinsics.xml - यहां 3x3 कैमरा मैट्रिक्स को लाइन द्वारा रिकॉर्ड किया जाएगा
  
• विरूपण। xml - वहाँ गुणांक की गणना की जाएगी।
  

यदि टेम्पलेट कुछ छवियों में नहीं पाया जाता है, तो इन चित्रों को दूसरों के साथ बेहतर प्रकाश व्यवस्था के साथ बदलने की कोशिश करें, संभवतः टेम्पलेट के कम तीव्र कोण पर। OpenCV को आसानी से टेम्पलेट के सभी आंतरिक बिंदुओं का पता लगाना चाहिए।
इन फ़ाइलों से नंबर होने पर, हम ओपनजीएल के लिए एक प्रक्षेपण मैट्रिक्स का निर्माण कर सकते हैं।

 float cameraMatrix[9] = {6.24860291e+02, 0., cameraSize.width*0.5f, 0., 6.24860291e+02, cameraSize.height*0.5f, 0., 0., 1.}; - (void)buildProjectionMatrix { // Camera parameters double f_x = cameraMatrix[0]; // Focal length in x axis double f_y = cameraMatrix[4]; // Focal length in y axis (usually the same?) double c_x = cameraMatrix[2]; // Camera primary point x double c_y = cameraMatrix[5]; // Camera primary point y double screen_width = cameraSize.width; // In pixels double screen_height = cameraSize.height; // In pixels double near = 0.1; // Near clipping distance double far = 1000; // Far clipping distance projectionMatrix[0] = 2.0 * f_x / screen_width; projectionMatrix[1] = 0.0; projectionMatrix[2] = 0.0; projectionMatrix[3] = 0.0; projectionMatrix[4] = 0.0; projectionMatrix[5] = 2.0 * f_y / screen_height; projectionMatrix[6] = 0.0; projectionMatrix[7] = 0.0; projectionMatrix[8] = 2.0 * c_x / screen_width - 1.0; projectionMatrix[9] = 2.0 * c_y / screen_height - 1.0; projectionMatrix[10] = -( far+near ) / ( far - near ); projectionMatrix[11] = -1.0; projectionMatrix[12] = 0.0; projectionMatrix[13] = 0.0; projectionMatrix[14] = -2.0 * far * near / ( far - near ); projectionMatrix[15] = 0.0; } 

कुछ नोट:

• हम अपने फ्रेम के केंद्र के साथ कैमरा मैट्रिक्स के गुणांक ( सीएक्स , साइबर ) को बदलते हैं। फिर फ्रेम में ऑब्जेक्ट के सापेक्ष 3 डी मॉडल का कोई विस्थापन नहीं होगा। पोस्ट के लेखक एक ही निष्कर्ष पर आए (लेख के अंत में अद्यतन देखें)।
  
• मैंने यहां से प्रक्षेपण मैट्रिक्स प्राप्त करने के लिए सूत्र लिया। वास्तव में, इस तरह एक परिप्रेक्ष्य प्रक्षेपण निर्धारित किया जाता है, जो हमारे कैमरे के मापदंडों और फ्रेम के आकार को ध्यान में रखता है।
  
• कैमरे का प्रस्तुत मैट्रिक्स आईफोन 4 के लिए मेरे द्वारा प्राप्त किया गया था। अन्य उपकरणों के लिए, मैट्रिक्स अलग होगा, हालांकि, मुझे लगता है, ज्यादा नहीं।
  

मैट्रिक्स मॉडल

इस मैट्रिक्स का निर्माण करते समय, StackOverflow में इस प्रश्न ने मेरी मदद की।
सौभाग्य से, OpenCV में आवश्यक कार्य पहले से ही लागू हैं।

तो कोड:

 float cameraMatrix[9] = {6.24860291e+02, 0., cameraSize.width*0.5f, 0., 6.24860291e+02, cameraSize.height*0.5f, 0., 0., 1.}; float distCoeff[5] = {1.61426172e-01, -5.95113218e-01, 7.10574386e-04, -1.91498715e-02, 1.66041708e+00}; - (void)buildModelViewMatrixUseOld:(BOOL)useOld { clock_t timer; startTimer(&timer); CvMat cvCameraMatrix = cvMat( 3, 3, CV_32FC1, (void*)cameraMatrix ); CvMat cvDistortionMatrix = cvMat( 1, 5, CV_32FC1, (void*)distCoeff ); CvMat* objectPoints = cvCreateMat( 4, 3, CV_32FC1 ); CvMat* imagePoints = cvCreateMat( 4, 2, CV_32FC1 ); // Defining object points and image points int minDimension = MIN(detector->modelWidth, detector->modelHeight)*0.5f; for (int i=0; i<4; i++) { float objectX = (detector->x_corner[i] - detector->modelWidth/2.0f)/minDimension; float objectY = (detector->y_corner[i] - detector->modelHeight/2.0f)/minDimension; cvmSet(objectPoints, i, 0, objectX); cvmSet(objectPoints, i, 1, objectY); cvmSet(objectPoints, i, 2, 0.0f); cvmSet(imagePoints, i, 0, detector->detected_x_corner[i]); cvmSet(imagePoints, i, 1, detector->detected_y_corner[i]); } CvMat* rvec = cvCreateMat(1, 3, CV_32FC1); CvMat* tvec = cvCreateMat(1, 3, CV_32FC1); CvMat* rotMat = cvCreateMat(3, 3, CV_32FC1); cvFindExtrinsicCameraParams2(objectPoints, imagePoints, &cvCameraMatrix, &cvDistortionMatrix, rvec, tvec); // Convert it CV_MAT_ELEM(*rvec, float, 0, 1) *= -1.0; CV_MAT_ELEM(*rvec, float, 0, 2) *= -1.0; cvRodrigues2(rvec, rotMat); GLfloat RTMat[16] = {cvmGet(rotMat, 0, 0), cvmGet(rotMat, 1, 0), cvmGet(rotMat, 2, 0), 0.0f, cvmGet(rotMat, 0, 1), cvmGet(rotMat, 1, 1), cvmGet(rotMat, 2, 1), 0.0f, cvmGet(rotMat, 0, 2), cvmGet(rotMat, 1, 2), cvmGet(rotMat, 2, 2), 0.0f, cvmGet(tvec, 0, 0) , -cvmGet(tvec, 0, 1), -cvmGet(tvec, 0, 2), 1.0f}; cvReleaseMat(&objectPoints); cvReleaseMat(&imagePoints); cvReleaseMat(&rvec); cvReleaseMat(&tvec); cvReleaseMat(&rotMat); printTimerWithPrefix((char*)"ModelView matrix computation", timer); } 

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



वस्तु के बिंदुओं के संबंध में कुछ बिंदु स्वयं हैं:

• ऑब्जेक्ट के बिंदु 3 डी में सेट किए गए हैं, और 2 डी में फ्रेम पर अंक। तदनुसार, यदि हम मानते हैं कि हम उन्हें z का एक शून्य-शून्य मान देते हैं, तो z पर मूल को फ्रेम में ऑब्जेक्ट के विमान के सापेक्ष स्थानांतरित कर दिया जाएगा। दो चित्रों के डेटा से समझना आसान है:
  
  
  z = 1.0
  
  
  z = 0.0
  
  
• इसके अलावा, हम ऑब्जेक्ट के बिंदुओं को सेट करते हैं ताकि हमारे लिए इस 3 डी स्पेस में काम करना अधिक सुविधाजनक हो। उदाहरण के लिए, मैं चाहता हूं कि मूल टेम्पलेट के केंद्र में सही हो, और लंबाई की इकाई आधा छोटा पक्ष (मिनीडिमेशन कोड में) हो। इस मामले में, हम पिक्सेल में टेम्पलेट के विशिष्ट आकार पर निर्भर नहीं करेंगे, और 3 डी अंतरिक्ष को छोटे तरफ बढ़ाया जाएगा।
  

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

कुल मिलाकर

दो मैट्रिसेस के निर्माण के लिए एक प्रक्रिया होने पर, हम सुरक्षित रूप से एक GLView बना सकते हैं, और वहां मॉडल बना सकते हैं। मैं ध्यान देता हूं कि मॉडल के मैट्रिक्स को खोजने का कार्य iPhone 4 पर 10 मिलीसेकंड से अधिक नहीं किया जाता है, अर्थात इसका उपयोग आपकी मान्यता के FPS को कम नहीं करेगा।
आपका ध्यान देने के लिए धन्यवाद।

और जानें:

1.http : //old.uvr.gist.ac.kr/wlee/web/techReports/ar/Camera%20Models.html
2. http://www.hitl.washington.edu/artoolkit/mail-archive/message-thread-00653-Re--Questions-concering-.html
3.http: //sightations.wordpress.com/2010/08/03/simulating-calibrated-cameras-in-engengl/
4.http : //www.songho.ca/opengl/gl_projectionmatrix.html