Tesseract OCR con Java con ejemplos

En este artículo, aprenderemos a trabajar con Tesseract OCR en Java usando la API de Tesseract .

¿Qué es Tesseract OCR?
Tesseract OCR es un motor óptico de lectura de caracteres desarrollado por los laboratorios HP en 1985 y de código abierto en 2005. Desde 2006 es desarrollado por Google. Tesseract es compatible con Unicode (UTF-8) y puede reconocer más de 100 idiomas «listos para usar» y, por lo tanto, también puede usarse para crear software de escaneo de diferentes idiomas. La última versión de Tesseract es Tesseract 4 . Agrega un nuevo motor de OCR basado en red neuronal (LSTM) que se centra en el reconocimiento de líneas, pero también es compatible con el motor Tesseract OCR heredado que funciona mediante el reconocimiento de patrones de caracteres.

¿Cómo funciona OCR?

En general, OCR funciona de la siguiente manera:

1. Preprocesar datos de imagen, por ejemplo: convertir a escala de grises, suavizar, desviar, filtrar.
2. Detecta líneas, palabras y caracteres.
3. Produce una lista clasificada de caracteres candidatos basada en un conjunto de datos entrenados. (aquí se usa el método setDataPath() para establecer la ruta de los datos del entrenador)
4. Posprocesa los caracteres reconocidos, elige los mejores caracteres en función de la confianza del paso anterior y los datos del idioma. Los datos de idioma incluyen diccionario, reglas gramaticales, etc.

Ventajas

Las ventajas de OCR son numerosas, pero a saber:

• aumenta la eficiencia y la eficacia del trabajo de oficina
• La capacidad de buscar instantáneamente en el contenido es inmensamente útil, especialmente en un entorno de oficina que tiene que lidiar con un gran volumen de escaneo o una gran cantidad de documentos.
• OCR es rápido asegurando que el contenido del documento permanezca intacto mientras ahorra tiempo también.
• El flujo de trabajo aumenta ya que los empleados ya no tienen que perder tiempo en trabajos manuales y pueden trabajar de manera más rápida y eficiente.

Desventajas

• El OCR se limita al reconocimiento de idiomas.
• Se requiere mucho esfuerzo para crear datos de entrenador de diferentes idiomas e implementarlos.
• También es necesario hacer un trabajo adicional en el procesamiento de imágenes, ya que es la parte más esencial que realmente importa cuando se trata del rendimiento de OCR.
• Después de hacer una gran cantidad de trabajo, ningún OCR puede ofrecer una precisión del 100 % e incluso después del OCR tenemos que determinar el carácter no reconocido mediante métodos vecinos de aprendizaje automático o corregirlo manualmente.

Cómo usar Tesseract OCR

1. El primer paso es descargar la API de Tess4J desde el enlace
2. Extraiga los archivos del archivo descargado
3. Abra su IDE y haga un nuevo proyecto
4. Vincule el archivo jar con su proyecto. Consulte este enlace .
5. Migre a través de esta ruta «..\Tess4J-3.4.8-src\Tess4J\dist».

Ahora ha terminado con su jar de enlace en su proyecto y está listo para usar el motor tesseract.

Realización de OCR en imágenes claras

Ahora que ha vinculado el archivo jar, podemos comenzar con nuestra parte de codificación. El siguiente código lee un archivo de imagen y realiza OCR y muestra texto en la consola.

import java.io.File;
  
import net.sourceforge.tess4j.Tesseract;
import net.sourceforge.tess4j.TesseractException;
  
public class Test {
    public static void main(String[] args)
    {
        Tesseract tesseract = new Tesseract();
        try {
  
            tesseract.setDatapath("D:/Tess4J/tessdata");
  
            // the path of your tess data folder
            // inside the extracted file
            String text
                = tesseract.doOCR(new File("image.jpg"));
  
            // path of your image file
            System.out.print(text);
        }
        catch (TesseractException e) {
            e.printStackTrace();
        }
    }

Aporte:

Producción:

05221859

Laboral:

Realización de OCR en imágenes poco claras

Tenga en cuenta que la imagen seleccionada arriba es en realidad muy clara y en escala de grises, pero esto no sucede en la mayoría de los casos. En la mayoría de los casos, obtenemos una imagen ruidosa y, por lo tanto, una salida muy ruidosa. Para lidiar con esto, necesitamos realizar un procesamiento en la imagen llamado Procesamiento de imagen .

Tesseract funciona mejor cuando hay una segmentación muy limpia del texto de primer plano del fondo. En la práctica, puede ser extremadamente difícil garantizar una buena segmentación. Hay una variedad de razones por las que es posible que no obtenga una salida de buena calidad de Tesseract si la imagen tiene ruido en el fondo. La eliminación de ruido de la imagen viene en la parte del procesamiento de imágenes. Para esto, necesitamos saber de qué manera se debe procesar una imagen.

Puede consultar este artículo para obtener una comprensión detallada de cómo puede mejorar la precisión. Para implementar lo mismo en JAVA, crearemos un pequeño modelo basado en inteligencia que escaneará el contenido RGB de la imagen y luego lo convertirá en contenido en escala de grises y también realizaremos algún efecto de zoom en la imagen.

El siguiente ejemplo es un código de muestra sobre cómo se puede escalar en gris la imagen en función de su contenido RGB. Entonces, si las imágenes son muy oscuras, se vuelven más brillantes y claras, y si las imágenes son blanquecinas, se escalan a un contraste poco oscuro para que el texto sea visible.

import java.awt.Graphics2D;
import net.sourceforge.tess4j.*;
import java.awt.Image;
import java.awt.image.*;
import java.io.*;
  
import javax.imageio.ImageIO;
  
public class ScanedImage {
  
    public static void
    processImg(BufferedImage ipimage,
               float scaleFactor,
               float offset)
        throws IOException, TesseractException
    {
        // Making an empty image buffer
        // to store image later
        // ipimage is an image buffer
        // of input image
        BufferedImage opimage
            = new BufferedImage(1050,
                                1024,
                                ipimage.getType());
  
        // creating a 2D platform
        // on the buffer image
        // for drawing the new image
        Graphics2D graphic
            = opimage.createGraphics();
  
        // drawing new image starting from 0 0
        // of size 1050 x 1024 (zoomed images)
        // null is the ImageObserver class object
        graphic.drawImage(ipimage, 0, 0,
                          1050, 1024, null);
        graphic.dispose();
  
        // rescale OP object
        // for gray scaling images
        RescaleOp rescale
            = new RescaleOp(scaleFactor, offset, null);
  
        // performing scaling
        // and writing on a .png file
        BufferedImage fopimage
            = rescale.filter(opimage, null);
        ImageIO
            .write(fopimage,
                   "jpg",
                   new File("D:\\Tess4J\\Testing and learning\\output.png"));
  
        // Instantiating the Tesseract class
        // which is used to perform OCR
        Tesseract it = new Tesseract();
  
        it.setDatapath("D:\\Program Files\\Workspace\\Tess4J");
  
        // doing OCR on the image
        // and storing result in string str
        String str = it.doOCR(fopimage);
        System.out.println(str);
    }
  
    public static void main(String args[]) throws Exception
    {
        File f
            = new File(
                "D:\\Tess4J\\Testing and learning\\Final Learning Results\\input.jpg");
  
        BufferedImage ipimage = ImageIO.read(f);
  
        // getting RGB content of the whole image file
        double d
            = ipimage
                  .getRGB(ipimage.getTileWidth() / 2,
                          ipimage.getTileHeight() / 2);
  
        // comparing the values
        // and setting new scaling values
        // that are later on used by RescaleOP
        if (d >= -1.4211511E7 && d < -7254228) {
            processImg(ipimage, 3f, -10f);
        }
        else if (d >= -7254228 && d < -2171170) {
            processImg(ipimage, 1.455f, -47f);
        }
        else if (d >= -2171170 && d < -1907998) {
            processImg(ipimage, 1.35f, -10f);
        }
        else if (d >= -1907998 && d < -257) {
            processImg(ipimage, 1.19f, 0.5f);
        }
        else if (d >= -257 && d < -1) {
            processImg(ipimage, 1f, 0.5f);
        }
        else if (d >= -1 && d < 2) {
            processImg(ipimage, 1f, 0.35f);
        }
    }
}

Aporte:

entrada.png

Producción:

salida.png

Laboral: