😻 🙊 ☝🏿 इमागो ओसीआर के उदाहरण का उपयोग करके संरचनात्मक जानकारी के लिए एक ऑप्टिकल पहचान प्रणाली का निर्माण 👈🏿 🍍 🤠

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

मान्यता इंजन संरचना

ऑप्टिकल पहचान प्रणाली के इंजन की संरचना को प्रदर्शित करने के लिए सबसे आम विकल्पों में से एक निम्नलिखित है:

परंपरागत रूप से, प्रसंस्करण विधियों को तीन स्तरों में विभाजित किया जा सकता है:

रेखापुंज स्तर (हम चित्र पिक्सेल के एक सेट के साथ काम करते हैं);
प्राइमेटीज़ का स्तर (हम कुछ प्राइमिटिज़ के साथ पिक्सेल के समूहों की पहचान करते हैं - प्रतीक, रेखाएं, मंडलियां, आदि);
संरचनात्मक स्तर (हम आदिम समूहों को तार्किक इकाइयों में इकट्ठा करते हैं - "तालिका", "तालिका सेल", "लेबल", आदि)

काले तीर के साथ, मैंने डेटा ट्रांसफर की मुख्य दिशा को दर्शाया: हम एक छवि को लोड करते हैं, इसे प्रसंस्करण के लिए एक सुविधाजनक रूप में परिवर्तित करते हैं, प्रिमिटिव प्राप्त करते हैं, प्रिमिटिव को संरचनाओं में व्यवस्थित करते हैं, परिणाम लिखते हैं।

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

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

रेखापुंज स्तर: छवि डाउनलोड

चूंकि हमने अद्भुत OpenCV लाइब्रेरी का उपयोग किया है, इसलिए यह कदम यथासंभव सरल है। OpenCV कई लोकप्रिय रेखापुंज स्वरूपों को लोड कर सकता है: PNG, JPG, BMP, DIB, TIFF, PBM, RAS, EXR और वास्तव में एक पंक्ति में:

cv::Mat mat = cv::imread(fname, CV_LOAD_IMAGE_GRAYSCALE);

चयनित पैरामीटर CV_LOAD_IMAGE_GRAYSCALE आपको पिक्सेल तीव्रता के मैट्रिक्स के रूप में एक तस्वीर अपलोड करने की अनुमति देता है (ग्रेस्केल में रूपांतरण स्वचालित रूप से होगा)। कुछ कार्यों में रंग जानकारी का उपयोग करना आवश्यक है, लेकिन हमारे यहां यह आवश्यक नहीं है, जो स्मृति आवंटन को महत्वपूर्ण रूप से सहेजने की अनुमति देता है। कैच में से, "पारदर्शी" PNGs को लोड करने के अलावा, पारदर्शी बैकग्राउंड को काले रंग के रूप में व्याख्या किया जाएगा, जिसे आसानी से CV_LOAD_IMAGE_UNCHANGED पैरामीटर के साथ डाउनलोड करके और मैन्युअल रूप से BGRA रंग जानकारी संसाधित कर सकते हैं (हाँ, OpenCV इस क्रम में रंग डेटा संग्रहीत करता है)।

इस स्तर पर हमें कुछ इस तरह मिलता है:

मैंने जानबूझकर तस्वीर को "बदतर" चुना, यह दिखाने के लिए कि ऑप्टिकल मान्यता कई कठिनाइयों से जुड़ी है जिसे हम आगे हल करेंगे, लेकिन यह "वास्तविक जीवन" से है - मोबाइल फोन कैमरे "और नहीं"।

रेखापुंज स्तर: पूर्व फ़िल्टरिंग

प्री-फ़िल्टरिंग का मुख्य कार्य छवि की "गुणवत्ता" में सुधार करना है: शोर को दूर करना, विस्तार में नुकसान के बिना और इसके विपरीत को बहाल करना।

एक ग्राफिक संपादक के साथ सशस्त्र, आप छवि की गुणवत्ता में सुधार करने के बारे में बहुत सारी पेचीदा योजनाओं का पता लगा सकते हैं, लेकिन यहां यह समझा जाना जरूरी है कि स्वचालित रूप से क्या किया जा सकता है और काल्पनिक क्या है, बिल्कुल एक छवि पर लागू होता है। यहां कम या ज्यादा स्वचालित दृष्टिकोणों के उदाहरण दिए गए हैं: स्पार्स मास्क , माध्यियन फिल्टर , उन लोगों के लिए जो Google को पसंद करते हैं ।

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

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

विधि के लाभों में शामिल हैं:

सुंदर उच्च गति;
परिणाम का पैरामीटर गुणवत्ता;
काम के दौरान कटाव का अभाव, और परिणामस्वरूप, विवरण के लिए "संवेदनशीलता";
और मुख्य दिलचस्प विशेषता रोशनी के स्थानीय स्तर का सामान्यीकरण है।

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

एल्गोरिथ्म की सतह का विवरण:

थ्रेशोल्ड टी के साथ स्थानीय थ्रेशोल्ड छवि फ़िल्टरिंग ( लैपलियन थ्रेसहोल्ड );
प्राप्त छवि का असतत कोसाइन रूपांतरण ;
उच्च आवृत्ति विशेषताओं को फ़िल्टर करना और निम्न और मध्यम आवृत्तियों (रेटिनेक्स समीकरण) के लिए एक विशेष समीकरण को हल करना;
उलटा असतत कोसाइन रूपांतरण।

एल्गोरिथ्म स्वयं पैरामीटर टी के प्रति संवेदनशील है, लेकिन हमने इसके अनुकूलन का उपयोग किया है:

हम T = 1,2,4,8 के लिए Retinex (T) पर विचार करते हैं
Retinex परिणामों के बीच प्रति पिक्सेल माध्य फ़िल्टरिंग
इसके विपरीत सामान्य करें

OpenCV कैसे मदद करेगा: असतत कोसाइन रूपांतरण की गणना के लिए एक तैयार कार्य है:

 void dct(const Mat& src, Mat& dst, int flags=0); // flags = DCT_INVERSE for inverse DCT

और यह libfftw से एक समान गति से भी बदतर काम नहीं करता है, हालांकि मैं इसे सामान्य मामले (कोर i5, कोर डुओ पर परीक्षण) में यह कहने के लिए नहीं मानता हूं।

मूल छवि के लिए, उपरोक्त विधि बहुत अच्छा परिणाम देती है:

अब हम मोटे तौर पर समझते हैं कि पूर्व फ़िल्टरिंग क्या करना चाहिए, और हमारे पास पहले से ही एक पैरामीटर है जो प्रतिक्रिया तंत्र में बदल सकता है: उपयोग किए गए फ़िल्टर का सूचकांक ।

इसके बाद : वास्तव में, निश्चित रूप से कई अन्य पैरामीटर हैं (उदाहरण के लिए, वही, "जादू" टी = 1,2,4,8), लेकिन "अपने सिर को टटोलने" के लिए नहीं, अब हम उनके बारे में बात नहीं करेंगे। उनमें से कई हैं, उनके संदर्भ मशीन लर्निंग पर अनुभाग में पॉप अप होंगे, लेकिन मैं बारीकियों को छोड़ दूँगा ताकि मापदंडों की संख्या के साथ प्रस्तुति को अधिभार न डालें।

रेखापुंज स्तर: द्विनेद्रीकरण

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

अधिक उन्नत तरीकों की अनुकूलन क्षमता के बावजूद, वे अभी भी थ्रेशोल्ड मान रखते हैं जो आउटपुट जानकारी की "राशि" निर्धारित करते हैं। अधिक गंभीर थ्रेसहोल्ड के मामले में - कुछ तत्व खो सकते हैं, "नरम" थ्रेसहोल्ड "शोर" के मामले में सामने आ सकते हैं।

मजबूत थ्रेसहोल्ड	कमजोर थ्रेसिंग

आप प्रत्येक छवि के लिए थ्रेसहोल्ड का सटीक अनुमान लगाने की कोशिश कर सकते हैं, लेकिन हम दूसरे तरीके से गए - हमने अलग-अलग अनुकूली द्विनेद्रीकरण थ्रेसहोल्ड के साथ प्राप्त छवियों के बीच संबंध का उपयोग किया:

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

परिणामस्वरूप, ज्यादातर मामलों में हमें शोर से रहित और बिना नुकसान के विस्तार में एक छवि मिलती है:

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

विभिन्न थ्रेशोल्ड फ़िल्टरिंग विधियों के साथ लागू किए जाने पर यह विचार काफी व्यवहार्य है, और ओपनसीवीवी ने "अनुकूली" बिल्ट-इन अनुकूली फ़िल्टरिंग फ़ंक्शन की उपस्थिति से किया है:

 cv::adaptiveThreshold(image, strongBinarized, 255, cv::ADAPTIVE_THRESH_GAUSSIAN_C, CV_THRESH_BINARY, strongBinarizeKernelSize, strongBinarizeTreshold); cv::threshold(image, otsuBinarized, otsuThresholdValue, 255, cv::THRESH_OTSU);

यदि अंतिम छवि में सेगमेंट बिल्कुल नहीं होते हैं, तो शायद एक फ़िल्टरिंग त्रुटि हुई है और यह एक और प्रारंभिक फ़िल्टर ("प्रतिक्रिया" पर विचार करने के लायक है; "वही" इंजन संरचना की छवि में नीले तीर)।

आदिम स्तर: वैश्वीकरण

मान्यता प्रक्रिया में अगला कदम पिक्सल (सेगमेंट) के सेटों को प्राइमिटिव में बदलना है। प्राइमिटिव्स के आंकड़े हो सकते हैं - एक सर्कल, सेगमेंट का एक सेट, एक आयत (प्राइमेटिक्स का एक विशिष्ट सेट हल होने वाली समस्या पर निर्भर करता है), या प्रतीक।

हालांकि हम यह नहीं जानते कि प्रत्येक वस्तु किस वर्ग की है, इसलिए हम इसे विभिन्न तरीकों से वेक्टर करने की कोशिश कर रहे हैं। पिक्सल के एक ही सेट को दोनों सेगमेंट के सेट के रूप में और प्रतीक के रूप में सफलतापूर्वक वेक्टर किया जा सकता है, उदाहरण के लिए, "N", "I"। या वृत्त और प्रतीक "O" हैं। इस स्तर पर, हमें मज़बूती से यह जानने की ज़रूरत नहीं है कि वस्तु किस वर्ग की है, लेकिन हमें एक निश्चित वर्ग में वस्तु की समानता का एक निश्चित मीट्रिक उसके वैश्वीकरण के साथ होना चाहिए। यह आमतौर पर पहचानने वाले कार्यों के एक समूह द्वारा हल किया जाता है।

उदाहरण के लिए, पिक्सेल के एक सेट के लिए

हमें निम्नलिखित वस्तुओं का एक सेट मिलेगा (मीट्रिक की विशिष्ट संख्याओं के बारे में न सोचें, उन्हें यह पहचानने के लिए दिया जाता है कि हम मान्यता प्रक्रिया से क्या चाहते हैं, लेकिन वे स्वयं अभी तक समझ में नहीं आते हैं):

0.1 के मीट्रिक (दूरी) मान के साथ "एच" प्रतीक के रूप में वेक्टरकरण (शायद यह बिल्कुल एच है) ;
4.93 के मीट्रिक मान के साथ प्रतीक "आर" के रूप में वेक्टरकरण (संभावना नहीं है, लेकिन यह संभव है कि यह भी आर) ;
तीन खंडों के रूप में वैश्वीकरण "|", "-", "|" 0.12 के मीट्रिक मान के साथ (यह संभव है कि ये तीन खंड हैं) ;
45.4 के एक मीट्रिक मूल्य के साथ पक्षों x, y के आयामों के साथ एक आयत के रूप में वेक्टरकरण;
मीट्रिक मूल्य + inf के साथ एक सर्कल के रूप में वेक्टरकरण (गारंटी एक सर्कल नहीं है) ;
...

वेक्टर की सूची प्राप्त करने के लिए, प्रत्येक विशेष वर्ग के लिए मान्यता प्रधानता को लागू करना आवश्यक है।

खंड सेट मान्यता

आमतौर पर, एक रेखापुंज क्षेत्र को खंडों के एक समूह में निम्न प्रकार से वर्गीकृत किया जाता है:

एक थिनिंग फ़िल्टर करना ( -> );
सेगमेंटेशन (डीकोर्नर) ( );
प्रत्येक खंड के बिंदुओं का अनुमान ;
परिणाम सन्निकटन का एक सेट है और मूल से सन्निकटन का एक विचलन है ।

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

 cv::approxPolyDP(curve, approxCurve, approxEps, closed); // approximation of curve -> approxCurve

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

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

 approxEps = averageLineThickness * magicLineVectorizationFactor;

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

मंडली की मान्यता

बहुत सरल:

हम सर्कल के केंद्र की तलाश कर रहे हैं (अंकों के निर्देशांक पर औसत) - (x, y);
हम त्रिज्या (केंद्र से बिंदुओं की औसत दूरी) की तलाश कर रहे हैं - आर;
हम त्रुटि पर विचार करते हैं: केंद्र (x, y) और त्रिज्या r और मोटाई औसत के साथ एक वृत्त के बिंदुओं से औसत दूरी;
हम सर्कल ब्रेक के लिए एक अतिरिक्त जुर्माना मानते हैं: मैजिककैरल पेनाल्टी * (ब्रेक का%)।

MagicCirclePenalty का चयन करने के बाद इस कोड के साथ-साथ इसके समान आयत मान्यता के साथ कोई समस्या नहीं थी।

चरित्र पहचान

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

इसलिए, चरित्र मान्यता के कई सबसिस्टम और कुल परिणाम के चुनाव का उपयोग करने का निर्णय काफी स्वाभाविक लग रहा था: यदि p1 = इस तथ्य का मीट्रिक मूल्य कि, एल्गोरिथ्म 1 के द्वारा, क्षेत्र A को प्रतीक s के रूप में पहचाना जाता है, और P2 = का मीट्रिक मान क्या एल्गोरिथम 2 क्षेत्र A को प्रतीक s के रूप में पहचानता है, तब अंतिम मान p = f (p1, P2)। हमने दो एल्गोरिदम को आसानी से तुलनीय मूल्यों, उच्च गति और पर्याप्त स्थिरता के साथ चुना है:

फूरियर विवरणकों के आधार पर मान्यता;
बिंदुओं के द्विघात विचलन के मुखौटे।

फूरियर विवरणकों के आधार पर चरित्र की पहचान

तैयारी:

वस्तु का बाहरी समोच्च प्राप्त करना;
समोच्च बिंदुओं (x; y) के निर्देशांक का जटिल संख्या में रूपांतरण x + iy;
इन संख्याओं के सेट का असतत फूरियर रूपांतरण;
स्पेक्ट्रम के उच्च आवृत्ति वाले हिस्से की अस्वीकृति।

उलटा फूरियर रूपांतरण करते समय, हमें उन बिंदुओं का एक सेट मिलता है, जो किसी दिए गए अंश के साथ मूल आकृति का वर्णन करता है (एन गुणांक के बाएं भाग है):

"मान्यता" ऑपरेशन में मान्यता प्राप्त क्षेत्र के लिए फूरियर विवरणकों की गणना करना और उन्हें पूर्वनिर्धारित सेटों के साथ तुलना करना शामिल है जो समर्थित वर्णों के लिए जिम्मेदार हैं। डिस्क्रिप्टर के दो सेट से मीट्रिक मूल्य प्राप्त करने के लिए, आपको कनवल्शन नामक एक ऑपरेशन करने की आवश्यकता है: d = sum ((d1 [i] -d2 [i]) * w [i], i = 1, N), जहां d1 और d2 डिस्क्रिप्टर के सेट हैं फूरियर, और w प्रत्येक गुणांक के लिए वजन वेक्टर है (हम इसे मशीन द्वारा प्राप्त किया था)। तुलनात्मक चिह्न तुलनात्मक प्रतीकों के पैमाने के संबंध में अपरिवर्तनीय है। इसके अलावा, फ़ंक्शन उच्च-आवृत्ति शोर (यादृच्छिक पिक्सेल जो आंकड़े की "ज्यामिति" नहीं बदलता है) के लिए प्रतिरोधी है।

OpenCV इस विधि को लागू करने में काफी मदद करता है; वस्तुओं की बाहरी आकृति प्राप्त करने के लिए एक तैयार कार्य है:

 cv::findContours(image, storage, CV_RETR_EXTERNAL);

और असतत फूरियर रूपांतरण की गणना के लिए एक समारोह है:

 cv::dft(src, dst);

यह केवल विवरणों के एक सेट को बचाने के लिए दृढ़ संकल्प और मध्यवर्ती प्रकार के रूपांतरणों को लागू करने के लिए बनी हुई है।

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

द्विघात विचलन मास्क के आधार पर चरित्र की मान्यता

यह एक बहुत सहज समाधान है, जो, जैसा कि यह निकला, किसी भी संकल्प के मुद्रित पात्रों के लिए महान काम करता है; यदि हमारे पास एक ही रिज़ॉल्यूशन की दो श्वेत-श्याम छवियां हैं, तो हम पिक्सेल द्वारा उनकी तुलना पिक्सेल से करना सीख सकते हैं।

छवि 1 के प्रत्येक बिंदु के लिए, एक दंड माना जाता है: समान रंग की छवि 2 के बिंदु के लिए न्यूनतम दूरी। तदनुसार, एक मीट्रिक सामान्य रूप से गुणांक के साथ जुर्माना का योग है। यह विधि शोर के साथ छोटे-रिज़ॉल्यूशन वाली छवियों पर बहुत अधिक स्थिर होगी: साइड लंबाई n के साथ एक छवि के लिए, व्यक्तिगत पिक्सेल k प्रतिशत तक खराब मामले में k * n से अधिक का मीट्रिक नहीं "खराब" करेगा, और व्यावहारिक मामलों में, k से अधिक होगा , क्योंकि ज्यादातर मामलों में वे छवि के "सही" पिक्सल से सटे होते हैं।

विधि का नुकसान, जैसा कि मैंने वर्णित किया है, कम गति होगी। प्रत्येक पिक्सेल (O (n ² )) के लिए, हम किसी अन्य चित्र (O (n ² )) के समान रंग के पिक्सेल की न्यूनतम दूरी पर विचार करते हैं, जो O (n ⁴ ) देता है।

लेकिन प्रीकोम्प्यूटिंग द्वारा इसका आसानी से इलाज किया जाता है: हम दो मास्क पेनल्टी_व्हीट (x, y) और पेनल्टीब्लाक (x, y) बनाएंगे, जिसमें गणना किए गए जुर्माना क्रमशः पिक्सेल या (x, y) सफेद या काले होने के लिए संग्रहीत किए जाएंगे। फिर "मान्यता" (यानी, मीट्रिक की गणना) की प्रक्रिया O (n ² ) में फिट होती है:

 for (int y = 0; y < img.cols; y++) { for (int x = 0; x < img.rows; x++) { penalty += (image(y,x) == BLACK) ? penalty_black(y,x) : penalty_white(y,x); } }

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

 cv::resize(temp, temp, cv::Size(size_x, size_y), 0.0, 0.0);

यदि हम चरित्र मान्यता की सामान्य प्रक्रिया पर लौटते हैं, तो दोनों विधियों को चलाने के परिणामस्वरूप हमें मीट्रिक मानों की एक तालिका मिलती है:

मान्यता मूल्य एक तत्व नहीं है, लेकिन पूरी तालिका जिसमें से हम जानते हैं कि उच्चतम संभावना के साथ यह प्रतीक "सी" है, लेकिन यह संभव है कि यह "0", या "6" (या "ओ", या "सी") हो। जो स्क्रीन पर फिट नहीं हुआ)। और अगर यह एक ब्रैकेट है, तो यह करीब से खुलने की अधिक संभावना है। लेकिन अभी के लिए, हम यह भी नहीं जानते कि क्या यह एक प्रतीक है ...

आदिम स्तर: पृथक्करण

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

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

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

और इसलिए, हम उस व्यक्ति से पूछते हैं कि यह क्या है -

बेशक, यह सिर्फ एक घुमावदार रेखा है। लेकिन अगर आपको इसे या तो प्रतीकों के रूप में या सीधे लाइन सेगमेंट के सेट के रूप में रैंक करने की आवश्यकता है, तो यह क्या है? तब यह सबसे अधिक संभावना है कि अक्षर "l" या दो सीधी रेखाएं एक कोण पर (बस कोने गोल खींची गई है)। लेकिन सही व्याख्या कैसे चुनें? पिछले चरण में मशीन एक अनुमानित समस्या को हल कर सकती है, और 1/2 की संभावना के साथ इसे सही ढंग से हल कर सकती है। लेकिन 1/2 संरचनात्मक जानकारी की मान्यता प्रणाली के लिए एक पूर्ण पतन है, हम सिर्फ संरचना को गड़बड़ करते हैं, यह सत्यापन पास नहीं करता है, आपको "त्रुटियों" को ठीक करना होगा, जो कि, अच्छे अवसर से, वास्तविक समस्या से मेल नहीं खा सकता है। .

, :

, - (, ). , , , « » — .

:

, , «» , , . , , , — . , «Cl» () , , - «l».

. .

:

«» ( ), C, .

, .

:

;
, ;
;
, ;
, hu moments ( OpenCV ).

, — , , — " ".

, : ( __-1 __+2, 3*__ 0.5* ), . , .

. — . , , - ( ). «» ( — , «l» , «l». , ).

:

;
, ;
: , .

« » — .

, , .

. , .

, Imago OCR , , ( ), . , . , . , .

, . , — , «» «», :

, «» , :

— . , , , , .

:

— (, ). , , , — ( , — ).

, . , «» ( ), «». , , — «» .

, «» . , — .
« » :

( baseline_y), , — . baseline_y :

( );
y , .

, ( )? ; , , , « ». baseline_y , — .

, . :

% , ;
.

: 30% — . 29? duck test. - , — . , - .

? , . . ( , ?). . , :

k% , f(k) ;
n% , , a..z g(n) .

, — , . «» .

— . — : — , , — . .

: {c1, c2}
c1 — «Y» 0.1 «X» 0.4;
c2 — «c» 0.3 «e» 0.8
, — Yc . Yc . . — .
4 , " Xe ", 1.2.

, . , «Yc» , . , (1.2) (0.4), (0.8). , , . ?

, , ? , , ?

— , . , , .

, — , . , . .

, , , , , , ; ( ) . , , — .

एक निष्कर्ष के बजाय

« » OCR , . , , , , . .

, , open-source Imago OCR , google .

इमागो ओसीआर के उदाहरण का उपयोग करके संरचनात्मक जानकारी के लिए एक ऑप्टिकल पहचान प्रणाली का निर्माण