अपनी त्वचा पर वियोला जोन्स, भाग 2 - भावना? - ओएमजी, हाँ !!!

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

परियोजना का विकास

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

इसके अलावा, गर्म पीछा में , यह पता चला कि आप काम की अनुमानित योजनाओं को स्केच कर सकते हैं
मानक

और फोटोग्राफी के साथ काम करने के लिए संशोधित वायोला-जोन्स विधि।

सहपाठियों का प्रारंभिक प्रशिक्षण

चूंकि क्लासिफ़ायर का उपयोग भावनाओं को पहचानने के लिए मॉड्यूल में किया जाता है, इसलिए उनकी शिक्षा और प्रशिक्षण के लिए क्रियाओं का एक क्रम विकसित किया गया है।

तो, क्लासिफायरियर को प्रशिक्षित करने के लिए, आपको आवश्यकता होगी:

• विकास उपकरण तैयार करना, ओपनसीवी पुस्तकालय का कनेक्शन;
• डेटा की तैयारी। उपयोग के लिए उपयुक्त:
- "सकारात्मक" और "नकारात्मक" छवियों (सकारात्मक और नकारात्मक छवि) के परीक्षण सेट। "सकारात्मक" छवियों में ब्याज की वस्तु (चेहरा, मुंह, नाक और इसी तरह) शामिल हैं,
"नकारात्मक" छवियों में केवल पृष्ठभूमि होती है;
- .vec-file, आसानी से पूरक, छवियों के समान सेटों से युक्त, केवल कम आकार में;
- तैयार छवियों के डेटाबेस, उनमें से बहुत सारे हैं। उदाहरण के लिए, FERET , OpenCV डेवलपर्स द्वारा उपयोग किया जाता है;
• एक पंक्ति में gluing, वांछित भाग के लिए सकारात्मक छवियों की कटाई;
• "पृष्ठभूमि में रुचि की वस्तु" के रूप में प्राकृतिक परीक्षण छवियों की तैयारी;
• ब्याज के क्षेत्रों (ब्याज के क्षेत्रों, आरओआई ) के प्राकृतिक परीक्षण छवियों के एक सेट पर हाइलाइटिंग, वास्तव में, उस जगह के निर्देशांक की स्थापना करना जहां ब्याज की वस्तु स्थित है;
• एक नए डेटा सेट पर बचत;
• नमूनों का निर्माण (प्रशिक्षण नमूने);
• प्रशिक्षण। इस स्तर पर:
- हरार वर्गीकरण प्रशिक्षण;
- एक XML फ़ाइल बनाना।

एकत्र किए गए छवि सेट डेटा फ़ोल्डर में एकत्र किए जाते हैं, और XML प्रारूप में Haar क्लासिफायर के रूप में कैस्केड्स को haarcascades फ़ोल्डर में जोड़ा जाता है।
प्रत्येक क्लासिफायरियर के लिए, अधीनस्थ विशेषताओं के साथ एक इकाई के रूप में व्यक्त किया गया, एक अलग XML संग्रहण बनाया जाना चाहिए। DOM (डॉक्यूमेंट ऑब्जेक्ट मॉडल), या रूसी में, सामान्य रूप में इस तरह के एक क्लासिफायर का दस्तावेज़ ऑब्जेक्ट मॉडल नीचे प्रस्तुत किया गया है। जड़ तत्व रिपोजिटरी है, पेड़ की लंबाई खुद 7 है।



कैस्केड में कई स्तर हैं - इसे क्लासिफायर के पहले स्तर के उदाहरण में देखा जा सकता है:



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

क्लासिफायर फ़ाइल संरचना

प्रोग्राम एल्गोरिदम के काम के परिणामस्वरूप, आउटपुट को नीचे दी गई सूची में दिखाए गए संरचना के साथ xml-files होना चाहिए। सभी xml फ़ाइलें संरचना और DOM मॉडल में समान होंगी।

<storage> <classifier1> <size></size> <stages> <_><!-- #of stage --> <trees> <_><!-- #of tree --> <_><!-- root node --> <feature> <rects><_></_><_></_></rects> <tilted></tilted> </feature> <threshold></threshold> <left_val></left_val> <right_val></right_val> </_></_></trees> <stage_threshold></stage_threshold> <parent></parent> <next></next> … </_></stages> <_></classifier1> </storage> 

नए डेटासेट तैयार करना

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



ऐसे नमूने createamples.cpp फ़ाइल का उपयोग करके बनाए जाते हैं, जो काम के लिए cvhaartrainig.h को लोड करते हैं। मैंने उन्हें मानक ओपनसीवी पुस्तकालय से लिया और अपनी आवश्यकताओं के लिए उन्हें "समाप्त" किया। ऐसे नमूने बनाते समय कई निर्दिष्ट पैरामीटर होते हैं; निम्नलिखित सूची में प्रस्तुत किए गए का उपयोग मेरे द्वारा किया जाता है, लेकिन ये सभी मापदंडों से बहुत दूर हैं:

 void reateTrainingSamples( const char* filename,//   ,    ,       const char* imgfilename,//    int bgcolor, //   int bgthreshold,//  ,   8-  const char* bgfilename, //   int count, int invert = 20,//      int maxintensitydev = 40,//        double maxxangle = 1.1,//      X double maxyangle = 1.1, //      Y double maxzangle = 0.5, //      Z int showsamples = 0,//  ,       int winwidth = 24,//        int winheight = 24//        ); 

परिणामस्वरूप, एक .dat फ़ाइल तुरंत बनाई जाती है, जहां हम ऐसी जानकारी देख सकते हैं: आगे की प्रक्रिया के लिए, परिणामी छवि को चिह्नित सुविधाओं के निर्देशांक के अनुसार एक नाम दिया गया है। उदाहरण में संख्याओं का मतलब है कि पाई गई वस्तुओं की संख्या 5 है और वस्तु के उदाहरण आयतों में {30, 49} के साथ पाए जाते हैं, और 469 और 250 की चौड़ाई और ऊंचाई:

../../ kalian2.png/0005_0030_0049_0469_0250.jpg 5 30 49 469 250

.Vec फ़ाइल के माध्यम से भी निर्माण संभव है, जिसका उपयोग OpenCV में किया जाता है, और जिसका उपयोग छवियों का प्रतिनिधित्व करने के लिए किया जाता है, इसमें फ़ाइल का नाम होता है और अतिरिक्त कोड का उपयोग करके इसका विस्तार किया जा सकता है। आप इसे veV फ़ाइल में addVec के माध्यम से जानकारी जोड़कर कर सकते हैं:

 addVec (oldvecname, newvecname, samplwidth, samplheight);//     ,  newvecname      ,   ,   oldvecname,         . 

पैरामीटर्स और क्लासिफायर ट्रेनिंग के चरण

नमूने बनाने के बाद अगला चरण क्लासिफायरियर प्रशिक्षण चरण है, जबकि मेरे द्वारा निर्धारित पैरामीटर निम्नानुसार हैं:

 void reateCascadeClassifier( const char* dirname,// ,       const char* vecfilename,// vec-       const char* bgfilename, //  ,   int npos,//   int nneg, //   int nstages,//     int numprecalculated,// ,     int numsplits,//  ,     : 1 – , 2   -  float minhitrate = 0.995F,//         float maxfalsealarm = 0.5F,//        float weightfraction = 0.95F,//   ,         90 int mode = 3,// ,     ,    . 0,  BASIC –  ,     -,    ,     2,  ALL    ,   45 ,   3            int symmetric = 1,// ,         ,    0,     int equalweights = 1,//    0,          int winwidth = 24,//  int winheight = 24,//  int boosttype = 3,//   ,  0 – Discrete AdaBoost, 1 – Real AdaBoost, 2 – LogitBoost, 3 – Gentle AdaBoost int stumperror = 0 );//  ,    Discrete AdaBoost 

इस चरण का परिणाम तैयार-से-उपयोग, प्रशिक्षित क्लासिफायरियर है। जो मॉड्यूल मैं विकसित कर रहा हूं, उसमें बहुत सारे क्लासिफायर लगाए जाएंगे (प्रत्येक चेहरे की विशेषताओं के लिए जो किसी दिए गए भाव के लिए विशिष्ट हैं), जिसे मैंने पहले से तैयार किया था, क्योंकि सहपाठियों को लंबे समय तक प्रशिक्षित किया जाता है। मैंने उन्हें विभिन्न कंप्यूटरों पर प्रशिक्षित किया। कंप्यूटर की कमजोर कंप्यूटिंग शक्ति के साथ प्रत्येक क्लासिफायर के बारे में तीन दिन लगते हैं! तो मैं सलाह देता हूं, अगर कोई समय सीमा है, तो अब काम करने के लिए नीचे उतरें:

 • face_identify_classifier.xml –   , • eyes_identify_classifier.xml –   , • eyebrows_identify_classifier.xml –   , • mouth_identify_classifier.xml –   , • nose_identify_classifier.xml –   , ... • happysmile_kalian_classifier.xml –    , • happyeyes_kalian_classifier.xml –   ,  , • happyeyebrows_kalian_classifier.xml –     , • surprisingeyes_kalian_classifier.xml –     ,    , • openingmouth_kalian_classifier.xml –      , • surprisingeyebrows_kalian_classifier.xml –   «»  (         ) 

स्वचालित भावना पहचान डिवाइस

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

• प्रारंभ में, विशेष फ़ंक्शन cvLoad () का उपयोग करते हुए , पहचान और मान्यता के लिए बनाए गए क्लासिफ़ायर लोड किए गए हैं, वे मेरी परियोजना (... \ _ haarcascades \) के हैरास्कैड फ़ोल्डर में स्थित हैं। निम्नलिखित मेमोरी मेमोरी का निर्माण है: storage = cvCreateMemStorage(0); :
  

   //  ,  ,   ,   void init(){//  ,       //     haarcascades cascade = (CvHaarClassifierCascade*)cvLoad( "haarcascades/mouth_disugst_classifier.xml" );//  //cascade1 = (CvHaarClassifierCascade*)cvLoad( "haarcascades/ eyes_identify_classifier.xml" );//  cascade1 = (CvHaarClassifierCascade*)cvLoad( "haarcascades/face_identify_classifier.xml" );//  cascade7 = (CvHaarClassifierCascade*)cvLoad( "haarcascades/haarcascade_frontalface_alt_tree.xml" );//  cascade2 = (CvHaarClassifierCascade*)cvLoad( "haarcascades/haarcascade_eye.xml" );//    //cascade3 = (CvHaarClassifierCascade*)cvLoad( "haarcascades/haarcascade_mcs_nose.xml" );//  cascade3 = (CvHaarClassifierCascade*)cvLoad( "haarcascades/haarcascade_kalian_nose.xml" );//  cascade4 = (CvHaarClassifierCascade*)cvLoad( "haarcascades/haarcascade_profileface.xml" );// //  cascade5 = (CvHaarClassifierCascade*)cvLoad( "haarcascades/smiled_01.xml" );//1 cascade8 = (CvHaarClassifierCascade*)cvLoad( "haarcascades/smiled_02.xml" );//2 cascade9 = (CvHaarClassifierCascade*)cvLoad( "haarcascades/smiled_03.xml" );//3 cascade10 = (CvHaarClassifierCascade*)cvLoad( "haarcascades/smiled_04.xml" );//4 cascade6 = (CvHaarClassifierCascade*)cvLoad( "haarcascades/haarcascade_mcs_eyepair_big.xml" );// ... //   storage = cvCreateMemStorage(0); 

  
  
• cvNamedWindow(); फ़ंक्शन का उपयोग करना cvNamedWindow(); एक विंडो दिखाई देती है जिसमें छवि के साथ और छवि पर ऑपरेशन के परिणाम दिखाई देंगे।
• यदि हम एक कैमरा का उपयोग करते हैं, तो हमें कैमरे से कैप्चर करने के लिए एक कोड की आवश्यकता होती है:
  
  

    //     CvCapture* capture = cvCreateCameraCapture(CV_CAP_ANY); //cvCaptureFromCAM( 0 ); assert( capture ); //cvSetCaptureProperty(capture, CV_CAP_PROP_FRAME_WIDTH, 640);//1280); //cvSetCaptureProperty(capture, CV_CAP_PROP_FRAME_HEIGHT, 480);//960); //      double width = cvGetCaptureProperty(capture, CV_CAP_PROP_FRAME_WIDTH); double height = cvGetCaptureProperty(capture, CV_CAP_PROP_FRAME_HEIGHT); printf("[i] %.0f x %.0f\n", width, height ); IplImage* frame=0; cvNamedWindow("capture", CV_WINDOW_AUTOSIZE); printf("[i] press Enter for capture image and Esc for quit!\n\n"); int counter=0; char filename[512]; while(true){ //   frame = cvQueryFrame( capture ); //  cvShowImage("capture", frame); char c = cvWaitKey(33); if (c == 27) { //  ESC break; } else if(c == 13) { // Enter //     sprintf(filename, "Image%d.jpg", counter); printf("[i] capture... %s\n", filename); cvSaveImage(filename, frame); counter++; } 

• कार्यक्रम में एक चक्र शामिल होता है जिसमें चित्रों की छवि या सरणी को क्रमिक रूप से मेमोरी में लोड किया जाता है:
  
  

    image = cvLoadImage( array_1[j], 1 ); printf("\n[i] Image loaded\n", image); assert( image!= 0 ); 

  
  
  यदि डेटा डेटाबेस में संग्रहीत है, तो इस स्तर पर आवश्यक mysql.h हेडर डेटाबेस से जुड़ा हुआ है, यदि आवश्यक हो तो डेटाबेस से प्रारंभिक कनेक्शन और डेटा को मेमोरी में लोड करना:
  
  

    #include <mysql.h> … //     void comlinePrint(char *); … //   MYSQL conn; //    MYSQL_RES *res; //     MYSQL_ROW row; //    if(!mysql_init(&conn)) comlinePrint("Error:   MySql - \n"); //      if(!mysql_real_connect(&conn,"localhost","kalian","","user",0,NULL,0)) comlinePrint("Error:    SQL \n"); //   ,   //    if(mysql_query(&conn, "SET NAMES 'cp1251'") != 0) { //     -  //    comlinePrint ("Error:   \n"); exit(1); } //    if(mysql_query(&conn,"INSERT INTO `user` VALUES(NULL, '', '','', 22, '', '','') ") != 0) { //      -  //    comlinePrint ("Error:      \n"); exit(1); } void comlinePrint(char * str) { printf(stderr, str); exit(1); } //       mysql_close(&conn);} 

• अगला, छवि का आकार बदलें। छवि की चौड़ाई और ऊंचाई की जाँच की जाती है और, स्थितियों के आधार पर, छवि n बार बढ़ती या घटती है:
  
  

    if(image->width>700 && image->height>700){ resPic = cvCreateImage( cvSize(image->width/1.5, image->height/1.5), image->depth, image->nChannels ); cvResize(image, resPic, 1); cvShowImage("resizing", resPic); printf ("\n[i] Image has been resized", image); comlinePrint(); else if(image->width<200 && image->height<200){ resPicMal = cvCreateImage( cvSize(image->width*2, image->height*2), image->depth, image->nChannels ); cvResize(image, resPicMal, 1); cvShowImage("resizing", resPicMal); 

फिर छवि मॉड्यूल के मुख्य चक्र में आती है। मेरी विकसित मान्यता पद्धति का मुख्य कार्य इस क्रम में जाने वाले कार्यों में विभाजित है:

1. imageGray (); // स्रोत छवि को ग्रेस्केल में बदलें
   
2. SobelPreparation (resPic, dst2); // Sobel ऑपरेटर द्वारा प्रारंभिक प्रसंस्करण
   
3. OtsuThresholdPreparation (resPic, ots1, ots2); // Otsu द्विपक्षीकरण
   
4. ImageCannyPreparation (resPic, dst); // कैनी डिटेक्टर द्वारा सीमाओं का चयन (परिणाम स्क्रीनशॉट में cvSub के साथ दिखाया गया है)
5. dilate (); // मिली बाउंड्रीज़ को मोटा करना * - इसका उपयोग नहीं किया जा सकता है, अधिकांश मामलों में इस फ़ंक्शन का उपयोग करने वाले प्रोग्राम परीक्षणों के परिणामों के अनुसार परिणाम में सुधार नहीं होता है, और कभी-कभी इसके बिना भी बदतर होता है
6. cvSub (ग्रे, img1, img1); // बाइनरी को मूल से घटाएं
   
7. चेहरे में पहचान और छवि में इसकी विशेषताएं;
8. पहचान (परिणाम); // भावना की गणना;
9. cvShowImage (& resPic); // मान्यता परिणाम
10. (cvWaitKey (1000)); // एक कीस्ट्रोक की प्रतीक्षा करें
11. cvReleaseImage (& resPic) // मुफ्त मेमोरी संसाधन

चेहरे और उनकी विशेषताओं का पता लगाने के लिए विन्यास योग्य पैरामीटर

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

   CvSeq* objects1 = cvHaarDetectObjects( img, cascade1, storage, 1.1, 4, 0|CV_HAAR_DO_CANNY_PRUNING, cvSize( 10, 20 ));// /*   CvSeq: CvSeq* cvHaarDetectObjects( const CvArr* image,// ,     CvHaarClassifierCascade* cascade,//  CvMemStorage* storage,//   double scale_factor = 1.1,//   int min_neighbors = 4,//   int flags = 0|CV_HAAR_DO_CANNY_PRUNING,//   CvSize min_size = cvSize(0,0)//   ); */ 

  
  
  फ़ंक्शन का संचालन, और पूरे मॉड्यूल का परिणाम cvHARDetectObjects () पर निर्भर करता है:
  
  न्यूनतम आसन्न दहलीज क्या तीव्रता चेहरे के प्रत्येक भाग पर है। इसे मैन्युअल रूप से कॉन्फ़िगर करना आवश्यक है, क्योंकि थ्रेसहोल्ड के बिना डिटेक्टर एक ही स्थान पर कई समान पहचान बनाता है। आमतौर पर अलग-थलग पड़े हुए झूठ झूठे होते हैं , इसलिए यह उन्हें त्यागने का मतलब है । यह भी एक इकाई में प्रत्येक चेहरे क्षेत्र के लिए कई हिरासत को संयोजित करने के लिए समझ में आता है।
  OpenCV इन दोनों स्थितियों का पता लगाने वाली वस्तुओं की सूची को वापस करने से पहले करता है।
  
  मर्ज चरण पहले आयतों को समूह बनाता है जिनमें बड़ी संख्या में ओवरलैप होते हैं, और फिर समूह के लिए औसत आयत का पता लगाता है।
  
  अगला, समूह में सभी आयतों की गणना गणना मध्य आयत के साथ की जाती है।
  अलग-अलग आयतों और बड़े समूहों के बीच छोटे समूह हैं जो चेहरे और झूठे हिरासत दोनों हो सकते हैं।
  
  न्यूनतम आसन्न थ्रेशोल्ड समूह में कितने कच्चे जासूस हैं, इसके आधार पर आयतों के समूहों को छोड़ने या बचाने के लिए कतरन स्तर निर्धारित करता है। डिफ़ॉल्ट रूप से, यह पैरामीटर तीन है, जिसका अर्थ है तीन या अधिक आयतों के समूह का विलय करना और कम आयतों वाले समूहों को त्यागना। यदि बड़ी संख्या में चेहरे और चेहरे की विशेषताओं की पहचान में कमी है , तो थ्रेशोल्ड मान को कम संख्या में होना चाहिए । यदि इसे शून्य पर सेट किया जाता है, तो फ़ंक्शन Haar क्लासिफायर के कच्चे जासूसों की पूरी सूची वापस कर देगा।
  
  डिफ़ॉल्ट मान से न्यूनतम पैमाने को बड़ा बनाने के लिए, आप इस पैरामीटर के लिए एक नया मान सेट कर सकते हैं। यदि आप मानक के अलावा किसी अन्य मूल्य का उपयोग करने का निर्णय लेते हैं, तो आपको यह सुनिश्चित करने की आवश्यकता है कि मानक अनुपात संरक्षित हैं (चौड़ाई का अनुपात ऊंचाई)। इस स्थिति में, पहलू अनुपात 1: 1 होगा।
  
  फ़ंक्शन का चौथा पैरामीटर निर्धारित करता है कि छवि के माध्यम से प्रत्येक पास के साथ चेहरे की पहचान के लिए ओपनसीवी कितनी जल्दी ज़ूम करेगा। इसे उच्च मूल्य पर सेट करने से डिटेक्टर तेजी से काम करता है (स्कैनिंग विंडो के कम पास के कारण), लेकिन अगर न्यूनतम पैमाना बहुत अधिक है, तो तराजू और लापता चेहरे के बीच बहुत जल्दी संक्रमण होने की संभावना है। डिफ़ॉल्ट रूप से, OpenCV में, इस पैरामीटर का मूल्य 1.1 है, या दूसरे शब्दों में, प्रत्येक पास के साथ 1.1 (10%) के कारक के साथ पैमाने बढ़ता है।
  
  CvHARDetectObject () फ़ंक्शन का ध्वज चर कई मान ले सकता है:
  - 0;
- CV_HAAR_DO_CANNY_PRUNING;
- CV_HAAR_FIND_BIGGEST_OBJECT;
- CV_HAAR_DO_ROUGH_SEARCH;
- CV_HAAR_DO_CANNY_PRUNING;
- CV_HAAR_SCALE_IMAGE.
  
  यदि "व्यावहारिक फसल" ध्वज का चयन किया गया है (0 | CV_HAAR_DO_CANNY_PRUNING), तो डिटेक्टर छवि के उन क्षेत्रों को छोड़ देता है जहां चेहरा अंदर होने की संभावना नहीं है, जो गणना के समय को कम करता है और संभवतः कुछ गलत पहचान को समाप्त करता है। स्केप्ड क्षेत्रों की पहचान एक ऐसे डिटेक्टर द्वारा की जाती है जो फेस डिटेक्टर को शुरू करने से पहले पूरी छवि में ऐसे "अनावश्यक" किनारों का पता लगाता है। फिर से, इस प्रकार के झंडे को सेट करना गति के बीच चयन करने और अधिक चेहरे खोजने के लिए एक समझौता है। झंडे को सेट करने से प्रसंस्करण की गति बढ़ जाएगी, लेकिन इसके परिणामस्वरूप कुछ व्यक्तियों को छोड़ दिया जा सकता है।
  
  न्यूनतम आकार जिसके द्वारा खोज की जाती है, को यथासंभव छोटा सेट किया जाना चाहिए, क्योंकि चेहरे का पैमाना निर्धारित नहीं किया जाएगा। डिफ़ॉल्ट रूप से, यह (0, 0) है, जिसका अर्थ है उस पैमाने का उपयोग करना जो क्लासिफायर xml-file में लिखा गया है।
  
  गलत तरीके से चयनित खोज मापदंडों के साथ खराब प्रशिक्षित क्लासिफायर के चरण में खराब चेहरे की पहचान का एक उदाहरण:
  
  
  
  एक अच्छी तरह से प्रशिक्षित क्लासिफायर के चरण में चेहरे की अच्छी पहचान का एक उदाहरण:
  
  
  
  
• कार्य पहचान करते हैं। परिणाम (रेसिपिक); यह पता लगाया जाता है कि किस प्रकार के क्लासिफायर ने पता लगाने में काम किया है । दूसरे शब्दों में, कौन सी वस्तु मिली थी। और अगर क्लासिफायर में भावनाएं जैसे संतुष्ट हालात पाए जाते हैं, तो जानकारी प्रदर्शित होती है कि भावना को परिभाषित किया गया है।
  
  उदाहरण के लिए, यदि निम्न सहपाठियों ने काम किया:
  

   • happysmile_kalian_classifier.xml, • happyeyes_kalian_classifier.xml, • happyeyebrows_kalian_classifier.xml 

  
  - यह आनंद की भावना है।
  
  
  - भावना? - हाँ !!!

मॉड्यूल और एल्गोरिथम परीक्षण

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

  int* numclassifiers = new int[cascade->count]; numclassifiers[0] = cascade->stage_classifier[0].count; for( i = 1; i < cascade->count; i++ ) { numclassifiers[i] = numclassifiers[i-1] + cascade->stage_classifier[i].count; } 

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

एल्गोरिथम / डेटा	वायोला-जोन्स ओपनसीवी	EmoRec (प्रस्तुत करने का + वियोला-जोन्स + OpenCV)
छवियों की सरणी (10 टुकड़े)	89%, ~ 7 सेकंड (7475 एमएस)	93%, ~ 7 सेकंड (7412 एमएस)
DB EmotionDB (15 टुकड़े)	92%, ~ 12 सेकंड (12167 एमएस)	94%, ~ 12 सेकंड (11870 एमएस)
* - पहचान का%, चरणों की संख्या (चरण), चेहरे को खोजने में बिताया गया कुल समय

निष्कर्ष

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

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

उन लोगों के लिए प्रश्न जो अंत तक पढ़े हैं

1. यह पूरी तरह से वियोला जोन्स एल्गोरिथ्म और इसके आवेदन को कवर करने के लिए निकला था?
2. मेरे हाथ काट दो या सामान्य रूप से पढ़ो?
3. और लिखूँ?
4. पुस्तकों और साइटों का चयन होता है। जैसा कि लेख लिखे जा रहे थे, मैंने वहां देखा और या तो सही पाया या कुछ नहीं पाया। लेकिन मेरे पास अभी भी फ़ोरम और साइट्स के पेज और लिंक के संकेत हैं। उन्हें एक अलग विषय बनाओ और इसे हैबर पर रखो?

आप सभी को धन्यवाद!और पढ़ें! नया साल मुबारक हो और शुभकामनाएँ! यह स्काईनोनाम

पीएस था मैं इस विषय पर आपकी आलोचना और सवालों की प्रतीक्षा कर रहा हूं! ठीक है, या आपके "धन्यवाद," अगर सामग्री ने कम से कम किसी तरह से आपकी मदद की ...