टेसरेक्ट ओसीआर सटीकता में सुधार करने के लिए छवि प्रसंस्करण

Question

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

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

छवि प्रसंस्करण पर नौसिखिया किसी के लिए कोई सामान्य युक्तियाँ?

Answer 1

1. ठीक डीपीआई (यदि आवश्यक) 300 डीपीआई न्यूनतम
2. ठीक पाठ का आकार है (उदाहरण के लिए 12 pt ठीक होना चाहिए)
3. पाठ लाइनों (deskew और dewarp पाठ)
4. ठीक करने की कोशिश ठीक करने की कोशिश छवि के रोशनी (जैसे छवि का कोई श्याम हिस्सा
5. binarize और de-शोर छवि

कोई सार्वभौमिक कमांड लाइन है कि सभी मामलों के लिए फिट हैं (कभी कभी आप ख की जरूरत नहीं है लूर और तेज छवि)। लेकिन आप TEXTCLEANER from Fred's ImageMagick Scripts पर आज़मा सकते हैं।

यदि आप कमांड लाइन के प्रशंसक नहीं हैं, तो आप ओपनसोर्स scantailor.sourceforge.net या वाणिज्यिक bookrestorer का उपयोग करने का प्रयास कर सकते हैं।

Answer 2

मैं किसी भी तरह से ओसीआर विशेषज्ञ नहीं हूं। लेकिन मुझे इस सप्ताह एक jpg से पाठ को बदलने की आवश्यकता थी।

मैंने रंगीन, आरजीबी 445x747 पिक्सेल jpg के साथ शुरू किया। मैंने तुरंत इस पर tesseract की कोशिश की, और कार्यक्रम लगभग कुछ भी परिवर्तित नहीं किया। मैं फिर जीआईएमपी में गया और निम्नलिखित किया। छवि> मोड> ग्रेस्केल छवि> स्केल छवि> 11 9 1x2000 पिक्सेल फ़िल्टर> एन्हांस्ड मास्क त्रिज्या = 6.8, राशि = 2.6 9, थ्रेसहोल्ड = 0 के मूल्यों के साथ बढ़ाएं, फिर मैंने 100% गुणवत्ता पर एक नया जेपीजी के रूप में सहेजा।

Tesseract तो एक .txt फ़ाइल

Gimp अपने दोस्त है में सभी पाठ को निकालने के लिए कर रहा था।

Answer 3

यह कुछ हद तक पहले है लेकिन यह अभी भी उपयोगी हो सकता है।

मेरा अनुभव दिखाता है कि टेसरेक्ट को पास करने से पहले छवि में स्मृति को आकार देने में कभी-कभी मदद मिलती है।

इंटरपोलेशन के विभिन्न तरीकों का प्रयास करें। पोस्ट https://stackoverflow.com/a/4756906/146003 ने मुझे बहुत मदद की।

Answer 4

कैप्चर 2 टेक्स्ट परियोजना के लिए इस तरह से एक्स्ट्रेमी हेल्पफुल मेरे लिए क्या है। http://sourceforge.net/projects/capture2text/files/Capture2Text/।

बीटीडब्लू: इस तरह के दर्दनाक एल्गोरिदम साझा करने के लिए इसके लेखक के लिए Kudos।

फ़ाइल कैप्चर 2 टेक्स्ट \ SourceCode \ leptonica_util \ leptonica_util.c पर विशेष ध्यान दें - यह इस उपयोगिता के लिए छवि प्रीप्रोसेशन का सार है।

यदि आप बाइनरी चलाएंगे, तो आप कैप्चर 2 टेक्स्ट \ आउटपुट \ फ़ोल्डर में प्रक्रिया के पहले/बाद में छवि परिवर्तन की जांच कर सकते हैं।

पीएस उल्लिखित समाधान प्रीप्रोकैसिंग के लिए ओसीआर और लेप्टनिका के लिए टेसेरैक्ट का उपयोग करता है।

Answer 5

छवि की पठनीयता में सुधार के लिए तीन अंक: 1) छवि को चरम ऊंचाई और चौड़ाई के साथ आकार बदलें (छवि ऊंचाई और चौड़ाई के साथ 0.5 और 1 और 2 गुणा करें)। 2) छवि को ग्रे स्केल प्रारूप (काला और सफेद) में कनवर्ट करें। 3) शोर पिक्सेल निकालें और अधिक स्पष्ट करें (छवि फ़िल्टर करें)।

कोड के नीचे देखें:

//Resize 
    public Bitmap Resize(Bitmap bmp, int newWidth, int newHeight) 
     { 

       Bitmap temp = (Bitmap)bmp; 

       Bitmap bmap = new Bitmap(newWidth, newHeight, temp.PixelFormat); 

       double nWidthFactor = (double)temp.Width/(double)newWidth; 
       double nHeightFactor = (double)temp.Height/(double)newHeight; 

       double fx, fy, nx, ny; 
       int cx, cy, fr_x, fr_y; 
       Color color1 = new Color(); 
       Color color2 = new Color(); 
       Color color3 = new Color(); 
       Color color4 = new Color(); 
       byte nRed, nGreen, nBlue; 

       byte bp1, bp2; 

       for (int x = 0; x < bmap.Width; ++x) 
       { 
        for (int y = 0; y < bmap.Height; ++y) 
        { 

         fr_x = (int)Math.Floor(x * nWidthFactor); 
         fr_y = (int)Math.Floor(y * nHeightFactor); 
         cx = fr_x + 1; 
         if (cx >= temp.Width) cx = fr_x; 
         cy = fr_y + 1; 
         if (cy >= temp.Height) cy = fr_y; 
         fx = x * nWidthFactor - fr_x; 
         fy = y * nHeightFactor - fr_y; 
         nx = 1.0 - fx; 
         ny = 1.0 - fy; 

         color1 = temp.GetPixel(fr_x, fr_y); 
         color2 = temp.GetPixel(cx, fr_y); 
         color3 = temp.GetPixel(fr_x, cy); 
         color4 = temp.GetPixel(cx, cy); 

         // Blue 
         bp1 = (byte)(nx * color1.B + fx * color2.B); 

         bp2 = (byte)(nx * color3.B + fx * color4.B); 

         nBlue = (byte)(ny * (double)(bp1) + fy * (double)(bp2)); 

         // Green 
         bp1 = (byte)(nx * color1.G + fx * color2.G); 

         bp2 = (byte)(nx * color3.G + fx * color4.G); 

         nGreen = (byte)(ny * (double)(bp1) + fy * (double)(bp2)); 

         // Red 
         bp1 = (byte)(nx * color1.R + fx * color2.R); 

         bp2 = (byte)(nx * color3.R + fx * color4.R); 

         nRed = (byte)(ny * (double)(bp1) + fy * (double)(bp2)); 

         bmap.SetPixel(x, y, System.Drawing.Color.FromArgb 
       (255, nRed, nGreen, nBlue)); 
        } 
       } 



       bmap = SetGrayscale(bmap); 
       bmap = RemoveNoise(bmap); 

       return bmap; 

     } 


//SetGrayscale 
    public Bitmap SetGrayscale(Bitmap img) 
     { 

      Bitmap temp = (Bitmap)img; 
      Bitmap bmap = (Bitmap)temp.Clone(); 
      Color c; 
      for (int i = 0; i < bmap.Width; i++) 
      { 
       for (int j = 0; j < bmap.Height; j++) 
       { 
        c = bmap.GetPixel(i, j); 
        byte gray = (byte)(.299 * c.R + .587 * c.G + .114 * c.B); 

        bmap.SetPixel(i, j, Color.FromArgb(gray, gray, gray)); 
       } 
      } 
      return (Bitmap)bmap.Clone(); 

     } 
//RemoveNoise 
    public Bitmap RemoveNoise(Bitmap bmap) 
     { 

      for (var x = 0; x < bmap.Width; x++) 
      { 
       for (var y = 0; y < bmap.Height; y++) 
       { 
        var pixel = bmap.GetPixel(x, y); 
        if (pixel.R < 162 && pixel.G < 162 && pixel.B < 162) 
         bmap.SetPixel(x, y, Color.Black); 
        else if (pixel.R > 162 && pixel.G > 162 && pixel.B > 162) 
         bmap.SetPixel(x, y, Color.White); 
       } 
      } 

      return bmap; 
     } 

इनपुट छवि

आउटपुट छवि

Answer 6

अनुकूली थ्रेशोल्डिंग महत्वपूर्ण है अगर प्रकाश छवि भर में असमान है। GraphicsMagic का उपयोग कर मेरी पूर्व प्रसंस्करण इस पोस्ट में बताया गया है: https://groups.google.com/forum/#!topic/tesseract-ocr/jONGSChLRv4

GraphicsMagic भी रैखिक समय अनुकूली सीमा-रेखा जिसके मैं जल्द ही कोशिश करेंगे के लिए -lat सुविधा है। ऊपर सत्यराज के कोड के लिए http://docs.opencv.org/trunk/doc/py_tutorials/py_imgproc/py_thresholding/py_thresholding.html

Answer 7

जावा संस्करण:

OpenCV का उपयोग कर थ्रेशोल्डिंग का एक अन्य तरीका यहाँ वर्णित है

// Resize 
public Bitmap resize(Bitmap img, int newWidth, int newHeight) { 
    Bitmap bmap = img.copy(img.getConfig(), true); 

    double nWidthFactor = (double) img.getWidth()/(double) newWidth; 
    double nHeightFactor = (double) img.getHeight()/(double) newHeight; 

    double fx, fy, nx, ny; 
    int cx, cy, fr_x, fr_y; 
    int color1; 
    int color2; 
    int color3; 
    int color4; 
    byte nRed, nGreen, nBlue; 

    byte bp1, bp2; 

    for (int x = 0; x < bmap.getWidth(); ++x) { 
     for (int y = 0; y < bmap.getHeight(); ++y) { 

      fr_x = (int) Math.floor(x * nWidthFactor); 
      fr_y = (int) Math.floor(y * nHeightFactor); 
      cx = fr_x + 1; 
      if (cx >= img.getWidth()) 
       cx = fr_x; 
      cy = fr_y + 1; 
      if (cy >= img.getHeight()) 
       cy = fr_y; 
      fx = x * nWidthFactor - fr_x; 
      fy = y * nHeightFactor - fr_y; 
      nx = 1.0 - fx; 
      ny = 1.0 - fy; 

      color1 = img.getPixel(fr_x, fr_y); 
      color2 = img.getPixel(cx, fr_y); 
      color3 = img.getPixel(fr_x, cy); 
      color4 = img.getPixel(cx, cy); 

      // Blue 
      bp1 = (byte) (nx * Color.blue(color1) + fx * Color.blue(color2)); 
      bp2 = (byte) (nx * Color.blue(color3) + fx * Color.blue(color4)); 
      nBlue = (byte) (ny * (double) (bp1) + fy * (double) (bp2)); 

      // Green 
      bp1 = (byte) (nx * Color.green(color1) + fx * Color.green(color2)); 
      bp2 = (byte) (nx * Color.green(color3) + fx * Color.green(color4)); 
      nGreen = (byte) (ny * (double) (bp1) + fy * (double) (bp2)); 

      // Red 
      bp1 = (byte) (nx * Color.red(color1) + fx * Color.red(color2)); 
      bp2 = (byte) (nx * Color.red(color3) + fx * Color.red(color4)); 
      nRed = (byte) (ny * (double) (bp1) + fy * (double) (bp2)); 

      bmap.setPixel(x, y, Color.argb(255, nRed, nGreen, nBlue)); 
     } 
    } 

    bmap = setGrayscale(bmap); 
    bmap = removeNoise(bmap); 

    return bmap; 
} 

// SetGrayscale 
private Bitmap setGrayscale(Bitmap img) { 
    Bitmap bmap = img.copy(img.getConfig(), true); 
    int c; 
    for (int i = 0; i < bmap.getWidth(); i++) { 
     for (int j = 0; j < bmap.getHeight(); j++) { 
      c = bmap.getPixel(i, j); 
      byte gray = (byte) (.299 * Color.red(c) + .587 * Color.green(c) 
        + .114 * Color.blue(c)); 

      bmap.setPixel(i, j, Color.argb(255, gray, gray, gray)); 
     } 
    } 
    return bmap; 
} 

// RemoveNoise 
private Bitmap removeNoise(Bitmap bmap) { 
    for (int x = 0; x < bmap.getWidth(); x++) { 
     for (int y = 0; y < bmap.getHeight(); y++) { 
      int pixel = bmap.getPixel(x, y); 
      if (Color.red(pixel) < 162 && Color.green(pixel) < 162 && Color.blue(pixel) < 162) { 
       bmap.setPixel(x, y, Color.BLACK); 
      } 
     } 
    } 
    for (int x = 0; x < bmap.getWidth(); x++) { 
     for (int y = 0; y < bmap.getHeight(); y++) { 
      int pixel = bmap.getPixel(x, y); 
      if (Color.red(pixel) > 162 && Color.green(pixel) > 162 && Color.blue(pixel) > 162) { 
       bmap.setPixel(x, y, Color.WHITE); 
      } 
     } 
    } 
    return bmap; 
} 

Answer 8

मैंने किया था इन एक छवि है जो बहुत छोटा नहीं है से बाहर अच्छे परिणाम प्राप्त करने के लिए पाठ।

1. मूल छवि पर धुंध लागू करें।
2. अनुकूली थ्रेसहोल्ड लागू करें।
3. तेज प्रभाव लागू करें।

और यदि अभी भी अच्छे नतीजे नहीं मिल रहे हैं, तो छवि को 150% या 200% तक स्केल करें।

Answer 9

टेसरेक्ट दस्तावेज़ में छवि प्रसंस्करण चरणों के माध्यम से how to improve the OCR quality पर कुछ अच्छे विवरण शामिल हैं।

कुछ डिग्री के लिए, टेसेरैक्ट स्वचालित रूप से उन्हें लागू करता है। टेस्सेक्ट को निरीक्षण के लिए एक मध्यवर्ती छवि लिखना भी संभव है, यानी यह जांचने के लिए कि आंतरिक छवि प्रसंस्करण कितनी अच्छी तरह से काम करता है (उपर्युक्त संदर्भ में tessedit_write_images खोजें)।

अधिक महत्वपूर्ण बात यह है कि new neural network system टेसेरैक्ट 4 में अधिक बेहतर ओसीआर परिणाम पैदा करता है - सामान्य रूप से और विशेष रूप से कुछ शोर वाली छवियों के लिए। यह --oem 1 के साथ सक्षम है, उदा।im के रूप में:

$ tesseract --oem 1 -l deu page.png result pdf 

(इस उदाहरण जर्मन भाषा का चयन)

इस प्रकार, यह समझ में आता है परीक्षण करने के लिए कुछ कस्टम पूर्व प्रसंस्करण छवि प्रसंस्करण चरणों लागू करने से पहले पहले कितनी दूर आप नए Tesseract LSTM मोड के साथ मिलता है ।

(देर से 2017 के रूप में, Tesseract 4 स्थिर अभी तक के रूप में जारी नहीं है, लेकिन विकास संस्करण प्रयोग करने योग्य है) किसी भी ओसीआर इंजन का उपयोग कर छवि दस्तावेजों से

Answer 10

पाठ पढ़ना क्रम में अच्छा सटीकता प्राप्त कई मुद्दे हैं। सभी मामलों के लिए कोई निश्चित समाधान नहीं है लेकिन यहां कुछ चीजें हैं जिन्हें ओसीआर परिणामों में सुधार के लिए माना जाना चाहिए।

1) पृष्ठभूमि क्षेत्र में खराब छवि गुणवत्ता/अवांछित तत्वों/ब्लब्स के कारण शोर की उपस्थिति। इसके लिए शोर हटाने जैसे कुछ प्री-प्रोसेसिंग ऑपरेशंस की आवश्यकता होती है जिसे गाऊशियन फ़िल्टर या सामान्य औसत फ़िल्टर विधियों का उपयोग करके आसानी से किया जा सकता है। ये ओपनसीवी में भी उपलब्ध हैं।

2) छवि का गलत अभिविन्यास: गलत अभिविन्यास के कारण ओसीआर इंजन छवियों में रेखाओं और शब्दों को सही ढंग से विभाजित करने में विफल रहता है जो सबसे खराब सटीकता देता है।

3) लाइनों की उपस्थिति: शब्द या रेखा विभाजन करने के दौरान ओसीआर इंजन कभी-कभी शब्दों और रेखाओं को एक साथ मर्ज करने की कोशिश करता है और इस प्रकार गलत सामग्री को संसाधित करता है और इसलिए गलत परिणाम देता है। अन्य मुद्दे भी हैं लेकिन ये मूलभूत हैं।

यह पोस्ट OCR application एक उदाहरण केस है जहां ओसीआर परिणाम पर कुछ छवि प्री-प्रीकासिंग और पोस्ट प्रोसेसिंग बेहतर ओसीआर सटीकता प्राप्त करने के लिए लागू किया जा सकता है।