Esto se discutió hace un año aquí:

¿OCR por lotes para muchos archivos PDF (no OCR)?

¿Hay alguna forma de agrupar archivos PDF de OCR que no hayan sido OCR? Este es, creo, el estado actual de las cosas relacionadas con dos problemas:

PDF de OCR por lotes

Ventanas

• Acrobat : este es el motor OCR más directo que procesará OCR por lotes. El único problema parece ser 1) no saltará archivos que ya han sido OCRed 2) intente arrojarle un montón de archivos PDF (algunos viejos) y vea cómo se bloquea. Es un pequeño buggy. Le advertirá en cada error que encuentre (aunque puede decirle al software que no lo notifique. Pero nuevamente, muere horriblemente en ciertos tipos de archivos PDF, por lo que su kilometraje puede variar.

• ABBYY FineReader (Batch / Scansnap), Omnipage : estos deben ser algunos de los peores programas de software conocidos por el hombre. Si puede descubrir cómo automatizar completamente (sin preguntar) el OCR por lotes de archivos PDF guardados con el mismo nombre , publique aquí. Parece que las únicas soluciones que pude encontrar fallaron en alguna parte: cambio de nombre, no totalmente automatizado, etc. etc. En el mejor de los casos, hay una manera de hacerlo, pero la documentación y la programación son tan horribles que nunca lo descubrirás.

• ABBYY FineReader Engine , ABBYY Recognition Server : estas son realmente más soluciones empresariales, probablemente sea mejor que solo acrobat ejecute una carpeta y pruebe y elimine los archivos PDF que le dan errores / bloquean el programa que pasar por la molestia de intentarlo para instalar software de evaluación (suponiendo que es un usuario final simple). No parece un costo competitivo para el pequeño usuario.

• ** Estación de trabajo Autobahn DX ** el costo de este producto es tan prohibitivo que probablemente podría comprar 6 copias de acrobat. No es realmente una solución para el usuario final. Si tiene una configuración empresarial, esto puede valer la pena para usted.

Linux

• WatchOCR : ya no se desarrolla y es básicamente imposible de ejecutar en distribuciones modernas de Ubuntu
• pdfsandwich : ya no se desarrolla, básicamente imposible de ejecutar en distribuciones modernas de Ubuntu
• ** ABBY LINUX OCR **: debe ser programable y parece tener buenos resultados:

http://www.splitbrain.org/blog/2010-06/15-linux_ocr_software_comparison

Sin embargo, al igual que muchos de estos otros productos de ABBYY que cobran por página, nuevamente, es mejor que intente hacer que Acrobat Batch OCR funcione.

• ** Ocrad, GOCR, OCRopus, tesseract, ** - estos pueden funcionar pero hay algunos problemas:

  1. Los resultados de OCR no son tan buenos como, por ejemplo, acrobat para algunos de estos (ver enlace anterior).
  2. Ninguno de los programas toma un archivo PDF y genera un archivo PDF. Debe crear un script y separar el PDF primero y ejecutar los programas sobre cada uno y luego volver a ensamblar el archivo como un pdf
  3. Una vez que lo haga, puede encontrar, como lo hice, que (tesseract) crea una capa de OCR que se desplaza. Entonces, si busca la palabra 'the', obtendrá un resaltado de la parte de la palabra al lado.

• Batch DjVu → Convertir a PDF: no lo he examinado, pero parece una horrible solución de combate.

En línea

• PDFcubed.com - vamos, no es realmente una solución por lotes.
• ABBYY Cloud OCR : no estoy seguro de si esta es realmente una solución por lotes, de cualquier manera, debe pagar por página y esto podría ser bastante costoso.

Identificación de archivos PDF sin OCR

Este es un problema un poco más fácil, que se puede resolver fácilmente en Linux y mucho menos en Windows. Pude codificar un script perl pdffontpara identificar si las fuentes están incrustadas para determinar qué archivos no están OCR.

"Soluciones" actuales

1. Use una secuencia de comandos para identificar archivos PDF no OCR (para no volver a ejecutar miles de archivos PDF OCR) y cópielos en un directorio temporal (conservando el árbol de directorios correcto) y luego use Acrobat en Windows para ejecutarlos con la esperanza de que los lotes no se estrellarán.

2. use el mismo script pero obtenga una de las herramientas de Linux OCR para que funcione correctamente, arriesgando la calidad de OCR.

Creo que voy a intentar el n. ° 1, solo estoy demasiado preocupado por los resultados de las herramientas de OCR de Linux (no creo que alguien haya hecho una comparación) y parece que separar los archivos y unirlos nuevamente Sería innecesaria la codificación si Adobe realmente puede OCR por lotes de un directorio sin asfixia.

Si desea una solución completamente gratuita, tendrá que usar un script para identificar los archivos PDF no OCR (o simplemente volver a ejecutar sobre los OCR), y luego usar una de las herramientas de Linux para probar y OCR. Teseract parece tener los mejores resultados, pero de nuevo, algunas de estas herramientas no son compatibles con las versiones modernas de Ubuntu, aunque si puede configurarlo y solucionar el problema que tuve cuando la capa de imagen no coincide con la capa de coincidencia de texto ( con tesseract), entonces tendría una solución bastante viable y una vez más Linux> Windows.

¿Tiene una solución de trabajo para automatizar completamente, PDF de OCR por lotes , omitiendo los archivos ya OCR con el mismo nombre, con alta calidad ? Si es así, realmente agradecería la entrada.

Script Perl para mover archivos no OCR a un directorio temporal. No puedo garantizar que esto funcione y probablemente deba reescribirse, pero si alguien lo hace funcionar (suponiendo que no funciona) o funciona mejor, avíseme y publicaré una versión mejor aquí.

#!/usr/bin/perl

# move non-ocred files to a directory
# change variables below, you need a base dir (like /home/joe/), and a sourcedirectory and output
# direcotry (e.g books and tempdir)
# move all your pdfs to the sourcedirectory

use warnings;
use strict;

# need to install these modules with CPAN or your distros installer (e.g. apt-get)
use CAM::PDF;
use File::Find;
use File::Basename;
use File::Copy;

#use PDF::OCR2;
#$PDF::OCR2::CHECK_PDF   = 1;
#$PDF::OCR2::REPAIR_XREF = 1;

my $basedir = '/your/base/directory';
my $sourcedirectory  = $basedir.'/books/';
my @exts       = qw(.pdf);
my $count      = 0;
my $outputroot = $basedir.'/tempdir/';
open( WRITE, >>$basedir.'/errors.txt' );

#check file
#my $pdf = PDF::OCR2->new($basedir.'/tempfile.pdf');
#print $pdf->page(10)->text;



find(
    {
        wanted => \&process_file,

        #       no_chdir => 1
    },
    $sourcedirectory
);
close(WRITE);

sub process_file {
    #must be a file
    if ( -f $_ ) {
        my $file = $_;
        #must be a pdf
        my ( $dir, $name, $ext ) = fileparse( $_, @exts );
        if ( $ext eq '.pdf' ) {
            #check if pdf is ocred
            my $command = "pdffonts \'$file\'";
            my $output  = `$command`;
            if ( !( $output =~ /yes/ || $output =~ /no/ ) ) {
                #print "$file - Not OCRed\n";
                my $currentdir = $File::Find::dir;
                if ( $currentdir =~ /$sourcedirectory(.+)/ ) {
                    #if directory doesn't exist, create
                    unless(-d $outputroot.$1){
                    system("mkdir -p $outputroot$1");
                    }
                    #copy over file
                    my $fromfile = "$currentdir/$file";
                    my $tofile = "$outputroot$1/$file";
                    print "copy from: $fromfile\n";
                    print "copy to: $tofile\n";
                    copy($fromfile, $tofile) or die "Copy failed: $!";
#                       `touch $outputroot$1/\'$file\'`;
                }
            }

        }

    }
}

También he buscado una manera de OCR por lotes de muchos archivos PDF de manera automatizada, sin mucha suerte. Al final, se me ocurrió una solución viable similar a la suya, usando Acrobat con un script de la siguiente manera:

1. Copie todos los PDF relevantes a un directorio específico.

2. Elimine los archivos PDF que ya contienen texto (suponiendo que ya sean OCRd o que ya sean texto; no es lo ideal, lo sé, pero lo suficientemente bueno por ahora).

3. Use AutoHotKey para ejecutar Acrobat automáticamente, seleccione el directorio específico y OCR todos los documentos, agregando "-ocr" a su nombre de archivo.

4. Mueva los PDF de OCRd a su ubicación original, usando la presencia de un archivo "-ocr.pdf" para determinar si fue exitoso.

Es un poco Heath Robinson , pero en realidad funciona bastante bien.

Creo que debe darse cuenta de que ABBYY FineReader es una solución para el usuario final diseñada para proporcionar un OCR rápido y preciso listo para usar.

Según mi experiencia, los proyectos de OCR tienen detalles significativamente diferentes cada vez y no hay forma de crear una alma de fábrica para cada caso único, pero puedo sugerirle más herramientas profesionales que pueden hacer el trabajo por usted:

• Eche un vistazo a ABBYY Recognition Server , este es un producto profesional para la automatización de OCR.

• Cuando se trata de Linux, eche un vistazo a http://ocr4linux.com , es una utilidad de línea de comandos que también puede adaptarse a usted.

• Para tareas más complejas, ABBYY tiene un SDK muy flexible como ABBYY FineReader Engine (alojado internamente) o ABBYY Cloud OCR SDK (basado en la nube de Microsoft Azure), que le permite diseñar el procesamiento de OCR de la manera que lo desee.

Fui parte del equipo de desarrollo front-end para el servicio en la nube especificado anteriormente y puedo proporcionar más información si es necesario.

Teniendo en cuenta la búsqueda de una capa de texto en PDF, no puedo dar ningún consejo al respecto, porque esta tarea está un poco al margen de OCR, que es mi especialidad, por lo que su enfoque de usar un script externo es muy razonable. Tal vez encuentre útil esta discusión: http://forum.ocrsdk.com/questions/108/check-if-pdf-is-scanned-image-or-contains-text

En linux

La mejor y más fácil forma de usarlo pypdfocres que no cambia el pdf

pypdfocr your_document.pdf

Al final, tendrá otro de your_document_ocr.pdfla forma que lo desee con texto de búsqueda. La aplicación no cambia la calidad de la imagen. Aumenta un poco el tamaño del archivo al agregar el texto superpuesto.

Para agrupar los archivos PDF

ls ./p*.pdf | xargs -L1 -I {}  pypdfocr {}

Si los archivos PDF están en subcarpetas:

tree -fai . | grep -P ".pdf$" | xargs -L1 -I {}  pypdfocr {}

Actualización 3 de noviembre de 2018:

pypdfocrya no es compatible desde 2016 y noté algunos problemas debido a que no se resolvió ocrmypdf( módulo ) hace un trabajo similar y se puede usar así:

ocrmypdf in.pdf out.pdf

Instalar:

pip install ocrmypdf

o

apt install ocrmypdf

entonces el comando se convertiría

tree -fai . | grep -P ".pdf$" | xargs -L1 -I {}  ocrmypdf {} {}_ocr.pdf 

Tuve cierto éxito a principios de 2015 haciendo OCR por lotes completamente sin intervención usando Nuance OmniPage Ultimate en Windows. No es gratis, precio de lista $ 500. Utilice el programa por lotes "DocuDirect" que se incluye. Tiene una opción "Ejecutar trabajo sin avisos" que parece la respuesta directa a su pregunta original.

Utilicé DocuDirect para generar un archivo PDF con capacidad de búsqueda para cada imagen PDF de entrada (es decir, sin capacidad de búsqueda); Se le puede pedir que replique el árbol del directorio de entrada en la carpeta de salida, así como los nombres de los archivos de entrada originales (casi, ver más abajo). Utiliza múltiples núcleos también. La precisión fue el mejor de los paquetes que evalué. Los documentos protegidos con contraseña se omiten (sin detener el trabajo, sin mostrar un diálogo).

Advertencia 1: Casi los nombres de archivo originales: el sufijo ".PDF" se convierte en ".pdf" (es decir, de mayúsculas a minúsculas) porque bueno, todo es lo mismo en Windows. (Ugh.)

Advertencia 2: No hay archivo de registro, por lo que el diagnóstico de qué archivos fallan durante el reconocimiento, lo que definitivamente hacen, es una decisión suya. DocuDirect producirá felizmente resultados confusos como páginas enteras que simplemente faltan. Escribí un script de Python usando el módulo PyPDF2 para implementar una validación cruda: probar que el recuento de páginas de salida coincidía con el recuento de páginas de entrada. Vea abajo.

Advertencia 3: un archivo de imagen de entrada borroso e indistinto hará que OmniPage se cuelgue para siempre, sin usar ninguna CPU; simplemente nunca se recupera. Esto realmente descarrila el procesamiento por lotes y no encontré ninguna solución. También informé esto a Nuance, pero no llegué a ninguna parte.

@ Joe tiene razón acerca de que el software está mal programado y documentado. Noto que el núcleo de OmniPage tiene una increíble tecnología mágica de reconocimiento de caracteres, pero la carcasa externa (GUI y procesamiento por lotes) es suficiente para que te saques el pelo.

Respaldo la sugerencia de @ Joe's y @ Kiwi de descartar archivos usando scripts, para presentar el paquete OCR solo con documentos de imagen desprotegidos.

Mi única afiliación con Nuance es como un cliente no exactamente satisfecho: tengo un lote de tickets de soporte no resueltos para probarlo :)

@ Joe: Respuesta tardía, pero tal vez aún sea relevante. Comunidad @SuperUser: Espero que sienta que esto es un tema.

** Actualización ** paquete sucesor es Nuance PowerPDF Advanced, precio de lista de solo $ 150. Tuve un éxito aún mayor con esto, es igual de preciso pero mucho más estable.

La secuencia de comandos python de validación de árbol previa / posterior a OCR sigue.

'''
Script to validate OCR outputs against inputs.
Both input and output are PDF documents in a directory tree.
For each input document, checks for the corresponding output
document and its page count.

Requires PyPDF2 from https://pypi.python.org/pypi/PyPDF2
'''

from __future__ import print_function
from PyPDF2 import PdfFileReader
import getopt
import os
import stat
import sys

def get_pdf_page_count(filename):
    '''
    Gets number of pages in the named PDF file.
    Fails on an encrypted or invalid file, returns None.
    '''
    with open(filename, "rb") as pdf_file:
        page_count = None
        err = None
        try:
            # slurp the file
            pdf_obj = PdfFileReader(pdf_file)
            # extract properties
            page_count = pdf_obj.getNumPages()
            err = ""
        except Exception:
            # Invalid PDF.
            # Limit exception so we don't catch KeyboardInterrupt etc.
            err = str(sys.exc_info())
            # This should be rare
            print("Warning: failed on file %s: %s" % (filename, err), file=sys.stderr)
            return None

    return page_count

def validate_pdf_pair(verbose, img_file, txt_file):
    '''
    Checks for existence and size of target PDF file;
    number of pages should match source PDF file.
    Returns True on match, else False.
    '''
    #if verbose: 
    #    print("Image PDF is %s" % img_file)
    #    print("Text PDF is %s" % txt_file)

    # Get source and target page counts
    img_pages = get_pdf_page_count(img_file)
    txt_pages = get_pdf_page_count(txt_file)
    if img_pages is None:
        # Bogus PDF, skip.
        print("Warning: failed to get page count for %s" % img_file, file=sys.stderr)
        return None
    if txt_pages is None:
        # Bogus PDF, skip.
        print("Warning: failed to get page count for %s" % txt_file, file=sys.stderr)
        return None

    retval = True
    if img_pages != txt_pages:
        retval = False
        print("Mismatch page count: %d in source %s, %d in target %s" % (img_pages, img_file, txt_pages, txt_file), file=sys.stderr)

    return retval


def validate_ocr_output(verbose, process_count, total_count, img_dir, txt_dir):
    '''
    Walks a tree of files to compare against output tree, calling self recursively.
    Returns a tuple with PDF file counts (matched, non-matched).
    '''
    # Iterate over the this directory
    match = 0
    nonmatch = 0
    for dirent in os.listdir(img_dir):
        src_path = os.path.join(img_dir, dirent)
        tgt_path = os.path.join(txt_dir, dirent)
        if os.path.isdir(src_path):
            if verbose: print("Found source dir %s" % src_path)
            # check target
            if os.path.isdir(tgt_path):
                # Ok to process
                (sub_match, sub_nonmatch) = validate_ocr_output(verbose, process_count + match + nonmatch, total_count, 
                                         src_path, tgt_path)
                match += sub_match
                nonmatch += sub_nonmatch
            else:
                # Target is missing!?
                print("Fatal: target dir not found: %s" % tgt_path, file=sys.stderr)

        elif os.path.isfile(src_path):
            # it's a plain file
            if src_path.lower().endswith(".pdf"):
                # check target
                # HACK: OmniPage changes upper-case PDF suffix to pdf;
                # of course not visible in Windohs with the case-insensitive 
                # file system, but it's a problem on linux.
                if not os.path.isfile(tgt_path):
                    # Flip lower to upper and VV
                    if tgt_path.endswith(".PDF"):
                        # use a slice
                        tgt_path = tgt_path[:-4] + ".pdf"
                    elif tgt_path.endswith(".pdf"):
                        tgt_path = tgt_path[:-4] + ".PDF"
                # hopefully it will be found now!
                if os.path.isfile(tgt_path):
                    # Ok to process
                    sub_match = validate_pdf_pair(verbose, src_path, tgt_path)
                    if sub_match:
                        match += 1
                    else:
                        nonmatch += 1
                    if verbose: print("File %d vs %d matches: %s" % (process_count + match + nonmatch, total_count, sub_match))

                else:
                    # Target is missing!?
                    print("Fatal: target file not found: %s" % tgt_path, file=sys.stderr)
                    nonmatch += 1

        else:
            # This should never happen
            print("Warning: not a directory nor file: %s" % src_path, file=sys.stderr)
    return (match, nonmatch)

def count_pdfs_listdir(verbose, src_dir):
    '''
    Counts PDF files in a tree using os.listdir, os.stat and recursion.
    Not nearly as elegant as os.walk, but hopefully very fast on
    large trees; I don't need the whole list in memory.
    '''
    count = 0
    for dirent in os.listdir(src_dir):
        src_path = os.path.join(src_dir, dirent)
        # stat the entry just once
        mode = os.stat(src_path)[stat.ST_MODE]
        if stat.S_ISDIR(mode):
            # It's a directory, recurse into it
            count += count_pdfs_listdir(verbose, src_path)
        elif stat.S_ISREG(mode):
            # It's a file, count it
            if src_path.lower().endswith('.pdf'):
                count += 1
        else:
            # Unknown entry, print an error
            print("Warning: not a directory nor file: %s" % src_path, file=sys.stderr)
    return count

def main(args):
    '''
    Parses command-line arguments and processes the named dirs.
    '''
    try:
        opts, args = getopt.getopt(args, "vi:o:")
    except getopt.GetoptError:
        usage()
    # default values
    verbose = False
    in_dir = None
    out_dir = None
    for opt, optarg in opts:
        if opt in ("-i"):
            in_dir = optarg
        elif opt in ("-o"):
            out_dir = optarg
        elif opt in ("-v"):
            verbose = True
        else:
            usage()
    # validate args
    if in_dir is None or out_dir is None: usage()
    if not os.path.isdir(in_dir):
        print("Not found or not a directory: %s" % input, file=sys.stderr)
        usage()
    if not os.path.isdir(out_dir):
        print("Not found or not a directory: %s" % out_dir, file=sys.stderr)
        usage()
    if verbose: 
        print("Validating input %s -> output %s" % (in_dir, out_dir))
    # get to work
    print("Counting files in %s" % in_dir)
    count = count_pdfs_listdir(verbose, in_dir)
    print("PDF input file count is %d" % count)
    (match,nomatch) = validate_ocr_output(verbose=verbose, process_count=0, total_count=count, img_dir=in_dir, txt_dir=out_dir) 
    print("Results are: %d matches, %d mismatches" % (match, nomatch))

def usage():
    print('Usage: validate_ocr_output.py [options] -i input-dir -o output-dir')
    print('    Compares pre-OCR and post-OCR directory trees')
    print('    Options: -v = be verbose')
    sys.exit()

# Pass all params after program name to our main
if __name__ == "__main__":
    main(sys.argv[1:])

Puede considerar el Autobahn DX de Aquaforest: http://www.aquaforest.com/en/autobahn.asp

Está diseñado para procesar lotes de archivos PDF y tiene una variedad de opciones (por ejemplo, saltar o pasar archivos OCR), así como opciones para el tratamiento inteligente de archivos PDF que pueden ofrecer un mejor resultado (por ejemplo, si un PDF tiene algunas páginas de imágenes y algunas páginas de texto, solo puede OCR las páginas de imagen)

En Maco Linux:

parallel --tag -j 2 ocrmypdf '{}' 'output/{}' ::: *.pdf

A partir de aquí .