Une comparaison entre IronOCR et Dynamsoft OCR

Les deux ensembles de logiciels offrent des solutions pour rogner les images pour l'OCR.

Lecture des régions rognées avec IronOCR

La branche d'Iron de Tesseract OCR est compétente pour lire des régions spécifiques d'images, comme montré dans l'exemple de code suivant.

Nous utilisons System.Drawing.Rectangle pour décrire la région exacte d'une image à lire en pixels.

Lorsqu'on traite un formulaire standardisé qui est rempli, et que seule une partie du contenu change d'un cas à l'autre, cela peut être très utile.

Numérisation d'une section de page : nous utilisons System.Drawing.Rectangle pour désigner une région à lire dans un document, ce qui améliore la vitesse et la précision.

using IronOcr;
using System.Drawing;

class Program
{
    static void Main(string[] args)
    {
        // Create an instance of IronTesseract
        var ocr = new IronTesseract();

        using (var input = new OcrInput())
        {
            // Define content area of interest
            var contentArea = new Rectangle() { X = 215, Y = 1250, Height = 280, Width = 1335 };

            // Add the specific region to the input
            input.AddImage("img/ComSci.png", contentArea);

            // Perform OCR operation
            var result = ocr.Read(input);

            // Output recognized text to console
            Console.WriteLine(result.Text);
        }
    }
}

using IronOcr;
using System.Drawing;

class Program
{
    static void Main(string[] args)
    {
        // Create an instance of IronTesseract
        var ocr = new IronTesseract();

        using (var input = new OcrInput())
        {
            // Define content area of interest
            var contentArea = new Rectangle() { X = 215, Y = 1250, Height = 280, Width = 1335 };

            // Add the specific region to the input
            input.AddImage("img/ComSci.png", contentArea);

            // Perform OCR operation
            var result = ocr.Read(input);

            // Output recognized text to console
            Console.WriteLine(result.Text);
        }
    }
}

Ceci résulte en une augmentation de 41 % de la vitesse, tout en nous permettant d'être plus précis. Cela est extrêmement précieux pour les applications OCR .NET impliquant des documents qui sont comparables et cohérents, y compris les factures, les reçus, les chèques, les formulaires, les réclamations de dépenses, etc.

Lorsque nous lisons des PDF, les ContentAreas (rognage OCR) sont également pris en charge.

Lecture des régions rognées avec Dynamsoft OCR

Pour commencer, lancez Visual Studio et construisez une nouvelle application Windows Forms C#, ou ouvrez-en une existante. Nous devrons inclure DynamicDotNetTWAIN.dll, DynamicOCR.dll, et le package de langue approprié.

1. Accédez à Outils -> Choisir des éléments de la boîte à outils, puis à l'onglet Composants .NET Framework, cliquez sur le bouton Parcourir et localisez DynamicDotNetTWAIN.dll.

2. Cliquez avec le bouton droit sur le fichier de projet dans l'Explorateur de solutions et sélectionnez Ajouter -> Élément existant... puis ajoutez les éléments nécessaires à partir du répertoire de ressources OCR.

Voici le code pour cliquer sur le bouton LoadImage:

private void button1_Click(object sender, EventArgs e) 
{
    OpenFileDialog filedlg = new OpenFileDialog(); 
    if (filedlg.ShowDialog() == DialogResult.OK) 
    { 
        dynamicDotNetTwain1.LoadImage(filedlg.FileName);
        // Choose an image from your local disk and load it into Dynamic .NET TWAIN
    } 
}

private void dynamicDotNetTwain1_OnImageAreaSelected(short sImageIndex, int left, int top, int right, int bottom) 
{
    dynamicDotNetTwain1.OCRTessDataPath = "../../"; 
    dynamicDotNetTwain1.OCRLanguage = "eng";
    OcrResultFormat ocrResultFormat = Dynamsoft.DotNet.TWAIN.OCR.ResultFormat.Text;

    byte [] sbytes = dynamicDotNetTwain1.OCR(dynamicDotNetTwain1.CurrentImageIndexInBuffer, left, top, right, bottom);
    // OCR the selected area of the image

    if (sbytes != null) 
    { 
        SaveFileDialog filedlg = new SaveFileDialog(); 
        filedlg.Filter = "Text File(*.txt)| *.txt"; 
        if (filedlg.ShowDialog() == DialogResult.OK) 
        {
            FileStream fs = File.OpenWrite(filedlg.FileName); 
            fs.Write(sbytes, 0, sbytes.Length);
            // Save the OCR result as a text file
            fs.Close(); 
        }
        MessageBox.Show("OCR successful");
    } 
    else 
    {
        MessageBox.Show(dynamicDotNetTwain1.ErrorString); 
    }
}

private void button1_Click(object sender, EventArgs e) 
{
    OpenFileDialog filedlg = new OpenFileDialog(); 
    if (filedlg.ShowDialog() == DialogResult.OK) 
    { 
        dynamicDotNetTwain1.LoadImage(filedlg.FileName);
        // Choose an image from your local disk and load it into Dynamic .NET TWAIN
    } 
}

private void dynamicDotNetTwain1_OnImageAreaSelected(short sImageIndex, int left, int top, int right, int bottom) 
{
    dynamicDotNetTwain1.OCRTessDataPath = "../../"; 
    dynamicDotNetTwain1.OCRLanguage = "eng";
    OcrResultFormat ocrResultFormat = Dynamsoft.DotNet.TWAIN.OCR.ResultFormat.Text;

    byte [] sbytes = dynamicDotNetTwain1.OCR(dynamicDotNetTwain1.CurrentImageIndexInBuffer, left, top, right, bottom);
    // OCR the selected area of the image

    if (sbytes != null) 
    { 
        SaveFileDialog filedlg = new SaveFileDialog(); 
        filedlg.Filter = "Text File(*.txt)| *.txt"; 
        if (filedlg.ShowDialog() == DialogResult.OK) 
        {
            FileStream fs = File.OpenWrite(filedlg.FileName); 
            fs.Write(sbytes, 0, sbytes.Length);
            // Save the OCR result as a text file
            fs.Close(); 
        }
        MessageBox.Show("OCR successful");
    } 
    else 
    {
        MessageBox.Show(dynamicDotNetTwain1.ErrorString); 
    }
}

Voici à quoi ressemble l'application:

La qualité de l'image d'entrée est le facteur déterminant le plus crucial dans la rapidité d'une tâche OCR. Plus le bruit de fond est faible et plus le dpi est élevé, avec une valeur cible idéale autour de 200 dpi, plus la sortie OCR sera rapide et précise.

Techniques de traitement d'image pour Dynamsoft OCR

Nous devons utiliser l'OCR dans une variété de situations, telles que scanner un numéro de carte de crédit avec notre téléphone ou extraire du texte à partir de documents papier. Les capacités OCR sont incluses dans la reconnaissance d'étiquettes Dynamsoft (DLR) et Dynamic Web TWAIN (DWT).

Bien qu'ils puissent faire un excellent travail en général, nous pouvons améliorer les résultats en utilisant diverses techniques de traitement d'image.

Alléger/retirer les ombres

Une illumination insuffisante peut avoir un impact sur le résultat OCR. Pour améliorer le résultat, nous pouvons éclaircir les photos ou éliminer les ombres des images.

Inverser

Parce que le moteur OCR est souvent entraîné sur du texte en couleurs sombres, le texte en couleurs claires peut être plus difficile à découvrir et reconnaître.

Il sera plus facile de le reconnaître si nous en invertissons la couleur

Pour effectuer l'inversion, nous pouvons utiliser le paramètre GrayscaleTransformationModes dans DLR.

Voici les paramètres JSON :

"GrayscaleTransformationModes": [
    {
        "Mode": "DLR_GTM_INVERTED"
    }
]

Resultat de lecture de DLR .net :

Redimensionner

Si la hauteur des lettres est trop faible, le moteur OCR peut ne pas produire un bon résultat. En général, l'image doit avoir un DPI d'au moins 300.

Il y a un paramètre ScaleUpModes dans DLR 1.1 qui vous permet d'agrandir les lettres. Bien sûr, nous pouvons redimensionner l'image nous-même.

Lire l'image directement donne un résultat incorrect :

Après avoir redimensionné l'image x2, le résultat est correct :

Déformer

Tout va bien si le texte est un peu déformé. Cependant, s'il est trop incliné, le résultat sera affecté négativement. Pour améliorer le résultat, nous avons besoin de rogner l'image.

Pour accomplir cela, nous pouvons utiliser la Transformée de Hough en OpenCV et Python.

Voici le code pour redresser l'image ci-dessus :

import cv2
import numpy as np
import math
from PIL import Image

def deskew():
    src = cv2.imread("neg.jpg", cv2.IMREAD_COLOR)
    gray = cv2.cvtColor(src, cv2.COLOR_BGR2GRAY)
    kernel = np.ones((5,5), np.uint8)
    erode_img = cv2.erode(gray, kernel)
    eroDil = cv2.dilate(erode_img, kernel)
    show_and_wait_key("eroDil", eroDil)

    canny = cv2.Canny(eroDil, 50, 150)
    show_and_wait_key("canny", canny)

    lines = cv2.HoughLinesP(canny, 0.8, np.pi / 180, 90, minLineLength=100, maxLineGap=10)
    drawing = np.zeros(src.shape[:], dtype=np.uint8)

    maxY = 0
    degree_of_bottomline = 0
    index = 0
    for line in lines:
        x1, y1, x2, y2 = line[0]
        cv2.line(drawing, (x1, y1), (x2, y2), (0, 255, 0), 1, lineType=cv2.LINE_AA)
        k = float(y1-y2)/(x1-x2)
        degree = np.degrees(math.atan(k))
        if index == 0:
            maxY = y1
            degree_of_bottomline = degree
        else:        
            if y1 > maxY:
                maxY = y1
                degree_of_bottomline = degree
        index += 1
    show_and_wait_key("houghP", drawing)

    img = Image.fromarray(src)
    rotate_img = img.rotate(degree_of_bottomline)
    rotate_img_cv = np.array(rotate_img)
    cv2.imshow("rotateImg", rotate_img_cv)
    cv2.imwrite("deskewed.jpg", rotate_img_cv)
    cv2.waitKey()

def show_and_wait_key(win_name, img):
    cv2.imshow(win_name, img)
    cv2.waitKey()

if __name__ == "__main__":
    deskew()

import cv2
import numpy as np
import math
from PIL import Image

def deskew():
    src = cv2.imread("neg.jpg", cv2.IMREAD_COLOR)
    gray = cv2.cvtColor(src, cv2.COLOR_BGR2GRAY)
    kernel = np.ones((5,5), np.uint8)
    erode_img = cv2.erode(gray, kernel)
    eroDil = cv2.dilate(erode_img, kernel)
    show_and_wait_key("eroDil", eroDil)

    canny = cv2.Canny(eroDil, 50, 150)
    show_and_wait_key("canny", canny)

    lines = cv2.HoughLinesP(canny, 0.8, np.pi / 180, 90, minLineLength=100, maxLineGap=10)
    drawing = np.zeros(src.shape[:], dtype=np.uint8)

    maxY = 0
    degree_of_bottomline = 0
    index = 0
    for line in lines:
        x1, y1, x2, y2 = line[0]
        cv2.line(drawing, (x1, y1), (x2, y2), (0, 255, 0), 1, lineType=cv2.LINE_AA)
        k = float(y1-y2)/(x1-x2)
        degree = np.degrees(math.atan(k))
        if index == 0:
            maxY = y1
            degree_of_bottomline = degree
        else:        
            if y1 > maxY:
                maxY = y1
                degree_of_bottomline = degree
        index += 1
    show_and_wait_key("houghP", drawing)

    img = Image.fromarray(src)
    rotate_img = img.rotate(degree_of_bottomline)
    rotate_img_cv = np.array(rotate_img)
    cv2.imshow("rotateImg", rotate_img_cv)
    cv2.imwrite("deskewed.jpg", rotate_img_cv)
    cv2.waitKey()

def show_and_wait_key(win_name, img):
    cv2.imshow(win_name, img)
    cv2.waitKey()

if __name__ == "__main__":
    deskew()

Lignes détectées :

Redressé :

Techniques de traitement d'image pour IronOCR

La qualité de l'image d'entrée n'est pas importante ici car IronOCR excelle à réparer les documents défaillants (bien que cela soit long et entraînera l'utilisation de plus de cycles CPU lors de vos tâches OCR).

Choisir des formats d'image d'entrée avec moins de bruit numérique, comme le TIFF ou le PNG, peut également donner des résultats plus rapides que les formats d'image avec perte, comme le JPEG.

Les filtres d'image listés ci-dessous peuvent considérablement améliorer la performance :

• OcrInput.Rotate(double degrees) — Tourne les images dans le sens des aiguilles d'une montre d'un nombre spécifié de degrés Les entiers négatifs sont utilisés pour la rotation dans le sens inverse des aiguilles d'une montre.
• OcrInput.Binarize() - Ce filtre d'image rend chaque pixel soit noir, soit blanc, sans intermédiaire. Cela peut améliorer la performance OCR dans des circonstances où le contraste texte-fond est très faible.
• OcrInput.ToGrayScale() - Ce filtre d'image convertit chaque pixel en une nuance de gris. Il est peu probable qu'il améliore la précision de l'OCR, mais il peut augmenter la vitesse.
• OcrInput.Contrast() - Augmente automatiquement le contraste. Dans les scans à faible contraste, ce filtre améliore fréquemment la vitesse et la précision de l'OCR.
• OcrInput.DeNoise() - Ce filtre ne devrait être utilisé que lorsque du bruit est attendu.
• OcrInput.Invert() - Inverse toutes les couleurs. Par exemple, le blanc devient noir : le noir devient blanc.
• OcrInput.Dilate() - Morphologie avancée. La dilatation est le processus consistant à ajouter des pixels aux bords des objets d'une image. (Inverse of Erode)
• OcrInput.Erode() - Une fonction de morphologie avancée. L'érosion est le processus de suppression des pixels des bords des objets. (Inverse of Dilate)
• OcrInput.Deskew() — Fait pivoter une image afin qu'elle soit orthogonale et à l'endroit. Comme Tesseract a une tolérance pour les scans inclinés qui peut descendre jusqu'à 5 degrés, cela est assez utile pour l'OCR.
• DeepCleanBackgroundNoise() - Supprime beaucoup de bruit de fond. N'utilisez ce filtre que si vous savez qu'il y a beaucoup de bruit de fond dans le document, car cela peut réduire la précision de l'OCR sur des documents clairs et est assez gourmand en ressources CPU.
• OcrInput.EnhanceResolution - Améliore la résolution des photos à basse résolution. En raison de OcrInput, ce filtre est rarement utilisé. OcrInput détectera et résoudra automatiquement la basse résolution.

Nous pourrions vouloir utiliser IronTesseract pour accélérer l'OCR sur des scans de meilleure qualité. Si nous cherchons la vitesse, nous pourrions commencer ici et ensuite réactiver les fonctions jusqu'à ce que le bon équilibre soit atteint.

using IronOcr;

class Program
{
    static void Main(string[] args)
    {
        var ocr = new IronTesseract();

// Configuration for speed tuning
        ocr.Configuration.BlackListCharacters = "~`$#^*_}{][|\\";
        ocr.Configuration.PageSegmentationMode = TesseractPageSegmentationMode.Auto;
        ocr.Configuration.TesseractVersion = TesseractVersion.Tesseract5;
        ocr.Configuration.EngineMode = TesseractEngineMode.LstmOnly;
        ocr.Language = OcrLanguage.EnglishFast;

        using (var input = new OcrInput(@"img\Potter.tiff"))
        {
            var result = ocr.Read(input);
            Console.WriteLine(result.Text);
        }
    }
}

using IronOcr;

class Program
{
    static void Main(string[] args)
    {
        var ocr = new IronTesseract();

// Configuration for speed tuning
        ocr.Configuration.BlackListCharacters = "~`$#^*_}{][|\\";
        ocr.Configuration.PageSegmentationMode = TesseractPageSegmentationMode.Auto;
        ocr.Configuration.TesseractVersion = TesseractVersion.Tesseract5;
        ocr.Configuration.EngineMode = TesseractEngineMode.LstmOnly;
        ocr.Language = OcrLanguage.EnglishFast;

        using (var input = new OcrInput(@"img\Potter.tiff"))
        {
            var result = ocr.Read(input);
            Console.WriteLine(result.Text);
        }
    }
}

Ce résultat est 99,8% précis comparé à la référence de 100% — mais 35% plus rapide.