Uma comparação entre o IronOCR e o Dynamsoft OCR.

Ambos os conjuntos de software oferecem soluções para recortar imagens para OCR.

Lendo regiões recortadas com IronOCR

O ramo do Tesseract OCR da Iron é hábil em ler regiões específicas de imagens, como mostrado na amostra de código a seguir.

Usamos System.Drawing.Rectangle para descrever a região exata de uma imagem a ser lida em pixels.

Ao lidar com um formulário padronizado que é preenchido, e somente uma parte do conteúdo muda de caso para caso, isso pode ser realmente útil.

Escaneando uma Seção de uma Página: Usamos System.Drawing.Rectangle para designar uma região para leitura em um documento, melhorando a velocidade e a precisão.

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);
        }
    }
}

Isso resulta em um aumento de 41 por cento na velocidade, ao mesmo tempo que nos permite ser mais específicos. Isso é extremamente valioso para aplicativos de OCR .NET envolvendo documentos comparáveis e consistentes, incluindo faturas, recibos, cheques, formulários, solicitações de despesas, e assim por diante.

Ao ler PDFs, ContentAreas (recorte de OCR) também é suportado.

Lendo regiões recortadas com OCR Dynamsoft

Para começar, inicie o Visual Studio e crie um novo C# Windows Forms Application, ou abra um já existente. Precisaremos incluir DynamicDotNetTWAIN.dll, DynamicOCR.dll e o pacote de idioma apropriado.

1. Navegue até Ferramentas -> Escolher Itens da Caixa de Ferramentas, depois vá até a guia Componentes do .NET Framework, clique no botão Procurar e localize DynamicDotNetTWAIN.dll.

2. Clique com o botão direito no arquivo do projeto no Solution Explorer e selecione Adicionar-> Item Existente... em seguida, adicione os itens necessários do diretório de recursos OCR.

Este é o código para clicar no botão 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); 
    }
}

É assim que a aplicação parece:

A qualidade da imagem de entrada é o fator mais crucial na velocidade de uma tarefa de OCR. Quanto menor o ruído de fundo e maior o dpi, com um valor de meta de cerca de 200 dpi, mais rápido e preciso será o resultado do OCR.

Técnicas de Processamento de Imagem para Dynamsoft OCR

Precisamos usar OCR em uma variedade de situações, como escanear um número de cartão de crédito com nosso telefone ou extrair texto de documentos em papel. Capacidades de OCR estão incluídas no Reconhecimento de Rótulos Dynamsoft (DLR) e no Dynamic Web TWAIN (DWT).

Embora possam fazer um excelente trabalho em geral, podemos melhorar os resultados usando várias técnicas de processamento de imagem.

Clarear/remover sombras

Iluminação pobre pode ter um impacto no resultado do OCR. Para melhorar o resultado, podemos clarear as fotos ou eliminar sombras das imagens.

Inverter

Como o mecanismo de OCR é frequentemente treinado em texto em cores escuras, texto em cores claras pode ser mais difícil de descobrir e reconhecer.

Será mais fácil de reconhecer se invertermos sua cor

Para realizar a inversão, podemos usar o parâmetro GrayscaleTransformationModes no DLR.

Aqui estão as configurações JSON:

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

Resultado da leitura do DLR .net:

Redimensionar

Se a altura das letras for muito baixa, o mecanismo de OCR pode não produzir um bom resultado. Em geral, a imagem deve ter um DPI de pelo menos 300.

Há um parâmetro ScaleUpModes no DLR 1.1 que permite aumentar o tamanho das letras. Podemos, é claro, redimensionar a imagem nós mesmos.

Ler a imagem diretamente resulta no resultado incorreto:

Após aumentar a imagem x2, o resultado está correto:

Desalinhar

Está tudo bem se o texto estiver um pouco distorcido. No entanto, se estiver excessivamente inclinado, o resultado será alterado adversamente. Para melhorar o resultado, precisamos cortar a imagem.

Para conseguir isso, podemos usar a Transformada de Linha de Hough no OpenCV e Python.

Aqui está o código para desalinhar a imagem acima:

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 = Imagem.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 = Imagem.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()

Linhas detectadas:

Desalinhado:

Técnicas de Processamento de Imagem para IronOCR

A qualidade da imagem de entrada não é importante aqui porque IronOCR se destaca em reparar documentos defeituosos (embora isso seja demorado e cause uso de mais ciclos de CPU em suas tarefas de OCR).

Escolher formatos de imagem de entrada com menos ruído digital, como TIFF ou PNG, também pode resultar em resultados mais rápidos do que formatos de imagem com perdas, como JPEG.

Os filtros de imagem listados abaixo podem melhorar significativamente o desempenho:

• OcrInput.Rotate(double degrees) — Rotaciona imagens no sentido horário por um número especificado de graus. Números inteiros negativos são usados para rotação no sentido anti-horário.
• OcrInput.Binarize() — Este filtro de imagem torna cada pixel preto ou branco, sem tons intermediários. Isso pode melhorar o desempenho do OCR em situações onde o contraste entre texto e fundo é muito baixo.
• OcrInput.ToGrayScale() — Este filtro de imagem converte cada pixel em um tom de escala de cinza. É improvável que melhore a precisão do OCR, mas pode aumentar a velocidade.
• OcrInput.Contrast() — Aumenta automaticamente o contraste. Em digitalizações de baixo contraste, este filtro frequentemente melhora a velocidade e a precisão do OCR.
• OcrInput.DeNoise() — Este filtro deve ser usado apenas quando se espera ruído.
• OcrInput.Invert() — Reverte todas as cores. Por exemplo, branco torna-se preto: preto torna-se branco.
• OcrInput.Dilate() — Morfologia avançada. Dilatação é o processo de adicionar pixels às bordas dos objetos em uma imagem. (Inverse of Erode)
• OcrInput.Erode() — Uma função avançada de morfologia. Erosão é o processo de remover pixels das bordas dos objetos. (Inverse of Dilate)
• OcrInput.Deskew() — Rotaciona uma imagem para que fique ortogonal e na posição correta. Como a tolerância do Tesseract para digitalizações enviesadas pode ser de apenas 5 graus, isso é bastante útil para OCR.
• DeepCleanBackgroundNoise() — Remove muito ruído de fundo. Use este filtro apenas se souber que há muito ruído de fundo no documento, pois pode reduzir a precisão do OCR em documentos claros e é bastante intensivo para a CPU.
• OcrInput.EnhanceResolution — Melhora a resolução de fotos de baixa resolução. Por causa de OcrInput, este filtro é raramente usado. OcrInput detectará e resolverá a baixa resolução automaticamente.

Podemos querer usar IronTesseract para acelerar o OCR em digitalizações de alta qualidade. Se estamos buscando velocidade, podemos começar aqui e posteriormente reativar recursos até alcançar o equilíbrio adequado.

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);
        }
    }
}

Este resultado é 99.8% preciso em comparação com a base de 100% — mas 35% mais rápido.