java - किसी छवि से किसी संख्या को पहचानें




image-processing ocr (4)

अधिकांश छवि प्रसंस्करण समस्याओं में आप जितनी अधिक हो सके उतनी जानकारी का लाभ उठाना चाहते हैं। छवि को देखते हुए ऐसी धारणाएं हैं जिन्हें हम कर सकते हैं (और संभवतः अधिक):

  1. संख्याओं के चारों ओर बक्से सुसंगत हैं।
  2. दाईं ओर की संख्या हमेशा 8 होती है (या समय से पहले ज्ञात)
  3. बाईं ओर की संख्या हमेशा एक संख्या है
  4. बाईं ओर की संख्या हमेशा हस्तलेखन और उसी व्यक्ति द्वारा लिखी जाती है

फिर हम उन धारणाओं का उपयोग करके समस्या को सरल बना सकते हैं:

  1. आप संख्याओं (टेम्पलेट मिलान) को खोजने के लिए एक सरल दृष्टिकोण का उपयोग कर सकते हैं। जब आपके पास मैच के निर्देशांक होते हैं तो आप एक उप छवि बना सकते हैं और टेम्पलेट को घटा सकते हैं और केवल उन नंबरों के साथ छोड़े जा सकते हैं जिन्हें आप ओसीआर इंजन को देना चाहते हैं। http://docs.opencv.org/doc/tutorials/imgproc/histograms/template_matching/template_matching.html
  2. यदि आप जानते हैं कि कौन से नंबरों की अपेक्षा की जा सकती है, तो आप उन्हें किसी अन्य स्रोत से प्राप्त कर सकते हैं और ओसीआर त्रुटियों को जोखिम नहीं उठा सकते हैं। आप टेम्पलेट के हिस्से के रूप में 8 भी शामिल कर सकते हैं।
  3. ओसीआर इंजन की शुद्धता में वृद्धि, इस पर आधारित, आप शब्दावली (संभव ओसीआर परिणाम) को बहुत कम कर सकते हैं। ऐसा करने के लिए टेस्सेक्टैक्टोक के लिए एक श्वेतसूची सेटिंग है ( https://code.google.com/p/tesseract-ocr/wiki/FAQ#How_do_I_recognize_only_digits ?)।
  4. ओसीआर इंजन को पहचानने के लिए हस्तलेखन बहुत कठिन है (वे मुद्रित फोंट के लिए हैं)। हालांकि, आप लेखक के "फ़ॉन्ट" को पहचानने के लिए ओसीआर इंजन को प्रशिक्षित कर सकते हैं। (देखें http://michaeljaylissner.com/posts/2012/02/11/adding-new-fonts-to-tesseract-3-ocr-engine/ )

हालांकि, किसी भी धारणा का उपयोग करना है कि आप समस्या को कम, सरल उप समस्याओं में कम करने के लिए कर सकते हैं। फिर यह देखने के लिए देखें कि इनमें से प्रत्येक उप-समस्या को अलग-अलग हल करने के लिए कौन से टूल्स उपलब्ध हैं।

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

मैं एक छवि के अंदर संख्याओं को खोजने और उन्हें जोड़ने के लिए एक आवेदन लिखने की कोशिश कर रहा हूँ।

मैं किसी छवि में लिखित संख्या की पहचान कैसे कर सकता हूं?

छवि में कई बक्से हैं जिन्हें मुझे बाईं ओर संख्याएं प्राप्त करने की आवश्यकता है और उन्हें कुल देने के लिए योग करें। इसे कैसे प्राप्त किया जा सकता है?

संपादित करें: मैंने छवि पर एक जावा टेसेरैक्ट ओसीआर किया लेकिन मुझे कोई सही परिणाम नहीं मिला। मैं इसे कैसे प्रशिक्षित कर सकता हूं?

भी

मैंने किनारे का पता लगाया मुझे यह मिला:


आपको सबसे अधिक संभावना निम्नलिखित करने की आवश्यकता होगी:

  1. पूरे पृष्ठ पर हफ़ ट्रांसफॉर्म एल्गोरिदम लागू करें, इसे पृष्ठ अनुभागों की एक श्रृंखला उत्पन्न करनी चाहिए।

  2. आपको प्राप्त होने वाले प्रत्येक अनुभाग के लिए, इसे फिर से लागू करें। यदि वर्तमान खंड में 2 तत्व उत्पन्न हुए हैं, तो आपको उपर्युक्त के समान आयताकार से निपटना चाहिए।

  3. एक बार जब आप कर लेंगे, तो आप संख्यात्मक मूल्य निकालने के लिए एक ओसीआर का उपयोग कर सकते हैं।

इस मामले में, मैं आपको JavaCV ( JavaCV जावा रैपर) पर एक नज़र डालने की JavaCV जो आपको हफ़ ट्रांसफॉर्म भाग से निपटने की अनुमति देनी चाहिए। इसके बाद आपको Tess4j ( Tess4j जावा रैपर) जैसी कुछ चीज चाहिए जो आपको बाद में होने वाली संख्याओं को निकालने की अनुमति देनी चाहिए।

एक अतिरिक्त नोट के रूप में, झूठी सकारात्मक राशि को कम करने के लिए, आप निम्न कार्य करना चाहेंगे:

  1. छवि को क्रॉप करें यदि आप निश्चित हैं कि कुछ निर्देशांक में आपके पास डेटा शामिल नहीं होगा। इससे आपको काम करने के लिए एक छोटी तस्वीर मिलनी चाहिए।

  2. छवि को ग्रे स्केल में बदलना बुद्धिमान हो सकता है (माना जाता है कि आप रंगीन छवि के साथ काम कर रहे हैं)। छवि को हल करने के लिए ओसीआर की क्षमता पर रंगों का नकारात्मक प्रभाव हो सकता है।

संपादित करें: आपकी टिप्पणी के अनुसार, इस तरह कुछ दिया गया है:

+------------------------------+
|                   +---+---+  |
|                   |   |   |  |
|                   +---+---+  |
|                   +---+---+  |
|                   |   |   |  |
|                   +---+---+  |
|                   +---+---+  |
|                   |   |   |  |
|                   +---+---+  |
|                   +---+---+  |
|                   |   |   |  |
|                   +---+---+  |
+------------------------------+

आप छवि को फसल करेंगे ताकि आप उस क्षेत्र को हटा दें जिसमें छवि को क्रॉप करके प्रासंगिक डेटा (बाएं भाग) नहीं है, तो आपको ऐसा कुछ मिल जाएगा:

+-------------+
|+---+---+    |
||   |   |    | 
|+---+---+    |
|+---+---+    |
||   |   |    |
|+---+---+    |
|+---+---+    |
||   |   |    |
|+---+---+    |
|+---+---+    |
||   |   |    |
|+---+---+    |
+-------------+

विचार हफ़ ट्रांसफॉर्म को चलाने के लिए होगा ताकि आप उस पृष्ठ के सेगमेंट प्राप्त कर सकें जिसमें आयताकार शामिल हैं:

+---+---+    
|   |   |     
+---+---+ 

फिर आप फिर से हफ़ ट्रांसफॉर्म लागू करेंगे और दो सेगमेंट के साथ समाप्त होंगे, और आप बाएं को ले लेंगे।

एक बार जब आपके पास बाएं सेगमेंट हो, तो आप ओसीआर लागू करेंगे।

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

इसके अलावा, आयत को चित्रित करने वाली अतिरिक्त रेखाएं ओसीआर को ट्रैक से फेंक सकती हैं, और इसे खराब परिणाम मिलती हैं।


मैं 2 बुनियादी तंत्रिका नेटवर्क घटकों को गठबंधन करने की सिफारिश करता हूं:

  • perceptron
  • स्वयं संगठित मानचित्र (एसओएम)

एक perceptron एक बहुत ही सरल तंत्रिका नेटवर्क घटक है। इसमें कई इनपुट होते हैं और 1 आउटपुट उत्पन्न करते हैं। आपको इनपुट और आउटपुट दोनों को खिलाकर इसे प्रशिक्षित करने की आवश्यकता है। यह एक आत्म सीखने का घटक है।

आंतरिक रूप से इसमें वजन घटकों का संग्रह होता है, जिसका उपयोग आउटपुट की गणना के लिए किया जाता है। प्रशिक्षण के दौरान इन वजन कारकों को परिपूर्ण किया जाता है। एक perceptron के बारे में सुंदर बात यह है कि, (एक उचित प्रशिक्षण के साथ) यह डेटा संभाल सकता है कि यह पहले कभी नहीं देखा है।

आप एक मल्टी लेयर नेटवर्क में इसे व्यवस्थित करके एक अवधारणा को अधिक शक्तिशाली बना सकते हैं, जिसका अर्थ है कि एक पेसेप्ट्रॉन का उत्पादन दूसरे परसेप्ट्रॉन के इनपुट के रूप में कार्य करता है।

आपके मामले में आपको 10 अवधारणा नेटवर्क का उपयोग करना चाहिए, प्रत्येक संख्यात्मक मान (0-9) के लिए एक।

लेकिन perceptrons का उपयोग करने के लिए आपको संख्यात्मक इनपुट की एक सरणी की आवश्यकता होगी। तो सबसे पहले आपको दृश्य छवि को संख्यात्मक मानों में बदलने के लिए कुछ चाहिए। एक स्वर्गित नक्शा (एसओएम) अंतर-जुड़े बिंदुओं के ग्रिड का उपयोग करता है। अंक आपकी छवि के पिक्सल पर आकर्षित किए जाने चाहिए (नीचे देखें)

2 घटक एक साथ अच्छी तरह से काम करते हैं। एसओएम की निश्चित संख्या में ग्रिड-नोड्स हैं, और आपके परसेप्ट्रॉन को निश्चित संख्या में इनपुट की आवश्यकता होती है।

दोनों घटक वास्तव में लोकप्रिय हैं और शैक्षणिक सॉफ्टवेयर पैकेज जैसे MATLAB

अद्यतन: 06/01/2018 - टेंसर प्रवाह

यह वीडियो ट्यूटोरियल दर्शाता है कि Google के टेंसरफ्लो फ्रेमवर्क का उपयोग करके पायथन में इसे कैसे किया जा सकता है। (लिखित ट्यूटोरियल के लिए here क्लिक here )।


हार मान लेना। वास्तव में। मैं एक इंसान के रूप में निश्चित रूप से यह नहीं कह सकता कि तीसरा अक्षर '1' या '7' है। मनुष्य समझने में बेहतर होते हैं, इसलिए कंप्यूटर इसके लिए असफल हो जाएगा। '1' और '7' केवल एक समस्याग्रस्त मामला है, '8' और '6', '3' और '9' को समझना / अलग करना भी मुश्किल है। आपका त्रुटि उद्धरण> 10% होगा। यदि सभी हस्तलेख एक ही व्यक्ति से हैं, तो आप इसके लिए ओसीआर को प्रशिक्षित करने का प्रयास कर सकते हैं, लेकिन इस मामले में भी आपको ~ 3% त्रुटियां मिलेंगी। यह हो सकता है कि आपका उपयोग केस विशेष है, लेकिन त्रुटियों की यह संख्या आमतौर पर किसी भी प्रकार की स्वचालित प्रसंस्करण को प्रतिबंधित करती है। अगर मुझे वास्तव में इसे स्वचालित करना है तो मैं मैकेनिकल तुर्क में देखूंगा।





hough-transform