Tesseract: reconocimiento óptico de caracteres Java simple

    Introducción

    Desarrollar símbolos que tengan algún valor es un rasgo exclusivo de los humanos. Reconocer estos símbolos y comprender las letras de una imagen es absolutamente normal para nosotros. En realidad, nunca captamos las letras como lo hacen las computadoras, basamos completamente nuestra capacidad para leerlas en nuestra vista.

    Por otro lado, las computadoras necesitan algo más concreto y organizado para trabajar. Necesitan una representación digital, no gráfica.

    A veces, esto simplemente no es posible. A veces, deseamos automatizar la tarea de reescribir texto a partir de una imagen con nuestras propias manos.

    Para estas tareas, Reconocimiento óptico de caracteres (OCR) se ideó como una forma de permitir que las computadoras «lean» contenido gráfico como texto, de manera similar a como lo hacen los humanos. Por supuesto, estos sistemas, si bien son relativamente precisos, aún pueden fallar bastante. Incluso si lo son, corregir los errores del sistema sigue siendo mucho más fácil y rápido que hacer todo desde cero a mano.

    Como todos los sistemas, el software de reconocimiento óptico de caracteres de naturaleza similar se entrena en conjuntos de datos preparados que lo alimentan con suficientes datos para aprender la diferencia entre los caracteres. También es muy importante cómo aprenden estas redes, si queremos que sean precisas, aunque este es un tema para otro artículo.

    En lugar de reinventar la rueda y encontrar una solución muy compleja (pero útil), tranquilicémonos un poco y usemos lo que ya se ofrece.

    Tesseract

    El gigante de la tecnología, Google, ha estado desarrollando un motor OCR, Tesseract, que tiene una historia de décadas desde su inicio original. Ofrece una API para varios lenguajes, aunque nos centraremos en la API de Tesseract Java.

    Tesseract es muy fácil de implementar y, por lo tanto, no es demasiado poderoso. Se utiliza principalmente para leer texto generado por computadora en imágenes en blanco y negro, lo que se hace con una precisión decente. Aunque en realidad no está diseñado para texto del mundo real.

    Para el reconocimiento óptico de caracteres avanzado en el mundo real, sería mejor usar algo como Visión de Google, que veremos en otro artículo.

    Dependencia de Maven

    Para importar el motor a nuestro proyecto, simplemente tenemos que agregar una dependencia:

    <dependency>
        <groupId>net.sourceforge.tess4j</groupId>
        <artifactId>tess4j</artifactId>
        <version>3.2.1</version>
    </dependency>
    

    Reconocimiento óptico de caracteres

    Usar Tesseract es absolutamente sencillo:

    Tesseract tesseract = new Tesseract();
    tesseract.setDatapath("E://DataScience//tessdata");
    System.out.println(tesseract.doOCR(new File("...")));
    

    Primero instanciamos el Tesseract objeto y establezca la ruta de datos a los modelos LSTM (Long Short-Term Memory) previamente entrenados para su uso.

    Los datos se pueden descargar desde el GitHub oficial cuenta.

    Luego, llamamos al doOCR() método, que acepta un archivo y devuelve una cadena: el contenido extraído.

    Démosle una imagen con letras negras grandes y claras sobre un fondo blanco:

    Alimentarlo con una imagen así producirá un resultado perfecto:

    Optical Character Recognition in Java is made easy with the help of Tesseract'
    

    Sin embargo, esta imagen es extremadamente fácil de escanear. Está normalizado, es de alta resolución y la fuente es consistente.

    Veamos qué pasa si intento escribir algo yo mismo, en un papel, y lo dejamos pasar por la aplicación:

    Podemos ver instantáneamente la diferencia que hace:

    A411“, written texz: is different {mm compatar generated but
    

    Algunas palabras están perfectamente bien y podría distinguir fácilmente «el texto escrito es diferente al generado por computadora», pero la primera y la última palabra están muy desviadas.

    Ahora, para que esto sea un poco más fácil de usar, transfiéralo a una aplicación Spring Boot muy simple para mostrar el resultado de una manera más agradable gráficamente.

    Implementación

    Aplicación Spring Boot

    En primer lugar, comencemos generando nuestro proyecto a través de Spring Initializr. Incluir la spring-boot-starter-web y spring-boot-starter-thymeleaf dependencias. Importaremos Tesseract manualmente:

    Controlador

    La aplicación no necesita más que un solo controlador, que ofrece nuestras dos vistas y maneja la carga de imágenes y el reconocimiento óptico de caracteres:

    @Controller
    public class FileUploadController {
        
        @RequestMapping("/")
        public String index() {
            return "upload";
        }
    
        @RequestMapping(value = "/upload", method = RequestMethod.POST)
        public RedirectView singleFileUpload(@RequestParam("file") MultipartFile file,
                                       RedirectAttributes redirectAttributes, Model model) throws IOException, TesseractException {
    
            byte[] bytes = file.getBytes();
            Path path = Paths.get("E://simpleocr//src//main//resources//static//" + file.getOriginalFilename());
            Files.write(path, bytes);
    
            File convFile = convert(file);
            Tesseract tesseract = new Tesseract();
            tesseract.setDatapath("E://DataScience//tessdata");
            String text = tesseract.doOCR(file2);
            redirectAttributes.addFlashAttribute("file", file);
            redirectAttributes.addFlashAttribute("text", text);
            return new RedirectView("result");
        }
    
        @RequestMapping("/result")
        public String result() {
            return "result";
        }
    
        public static File convert(MultipartFile file) throws IOException {
            File convFile = new File(file.getOriginalFilename());
            convFile.createNewFile();
            FileOutputStream fos = new FileOutputStream(convFile);
            fos.write(file.getBytes());
            fos.close();
            return convFile;
        }
    }
    

    Tesseract funciona con Java Files, pero no es compatible MultipartFile, que obtenemos al aceptar un archivo a través de nuestro formulario. Para mitigar esto, hemos agregado un simple convert() método, que convierte el MultipartFile en un regular File.

    Una vez que hemos extraído el texto usando Tesseract, simplemente lo agregamos al modelo, junto con la imagen escaneada y lo agregamos a la vista redirigida. result.

    Puntos de vista

    Ahora, definamos una vista que podemos usar para simplemente cargar un archivo a través de un formulario:

    <html>
    <body>
    <h1>Upload a file for OCR:</h1>
    
    <form method="POST" action="/upload" enctype="multipart/form-data">
        <input type="file" name="file" /><br/><br/>
        <input type="submit" value="Submit" />
    </form>
    
    </body>
    </html>
    

    Y la página resultante:

    <html xmlns:th="http://www.thymeleaf.org">
    <body>
    
    <h1>Extracted Content:</h1>
    <h2>><span th:text="${text}"></span></h2>
    
    <p>From the image:</p>
    <img th:src=""https://Pharos.sh.com/" + ${file.getOriginalFilename()}"/>
    </body>
    </html>
    

    La ejecución de esta aplicación nos dará la bienvenida con una interfaz sencilla:

    Agregar una imagen y enviarla resultará en la extracción del texto y la imagen mostrada en la pantalla:

    ¡Éxito!

    Conclusión

    Usando el motor Tesseract de Google, creamos una aplicación extremadamente simple que acepta una imagen a través de un formulario, extrae el contenido textual y nos devuelve la imagen enviada.

    Esta no es una aplicación particularmente útil en sí misma, debido al poder limitado de Tesseract y al hecho de que la aplicación es demasiado simple para cualquier otro uso además de los propósitos de demostración, pero debería servir como una herramienta divertida que podría implementar y probar. con.

    El reconocimiento óptico de caracteres puede resultar útil cuando desee digitalizar contenido, especialmente cuando se trata de documentos. Son fáciles de escanear y bastante precisos cuando se trata de extraer contenido. Por supuesto, siempre es aconsejable revisar el documento resultante para detectar posibles errores.

     

    Etiquetas:

    Deja una respuesta

    Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *