Cela a été discuté il y a un an ici:

OCR par lots pour de nombreux fichiers PDF (pas déjà OCR)?

Existe-t-il un moyen de grouper des PDF OCR qui n'ont pas déjà été OCR? Tel est, je pense, l'état actuel des choses concernant deux questions:

PDF OCR par lots

les fenêtres

• Acrobat - Il s'agit du moteur ocr le plus simple qui fournira l'OCR par lots. Le seul problème semble être 1) il ne sautera pas les fichiers qui ont déjà été OCR 2) essayez de jeter un tas de PDF dessus (certains anciens) et de le regarder planter. C'est un petit buggy. Il vous avertira à chaque erreur qu'il rencontre (bien que vous puissiez dire au logiciel de ne pas le signaler. Mais encore une fois, il meurt horriblement sur certains types de PDF, donc votre kilométrage peut varier.

• ABBYY FineReader (Batch / Scansnap), Omnipage - Ceux-ci doivent être parmi les pires logiciels programmés connus de l'homme. Si vous pouvez découvrir comment automatiser complètement (sans invite) l'OCR par lots de fichiers PDF enregistrés avec le même nom, veuillez poster ici. Il semble que les seules solutions que j'ai pu trouver aient échoué quelque part - renommer, pas entièrement automatisées, etc. etc. Au mieux, il existe un moyen de le faire, mais la documentation et la programmation sont si horribles que vous ne le découvrirez jamais.

• ABBYY FineReader Engine , ABBYY Recognition Server - Ce sont vraiment plus de solutions d'entreprise, vous feriez probablement mieux de simplement faire acrobat pour exécuter sur un dossier et essayer d'éliminer les fichiers PDF qui vous donnent des erreurs / planter le programme que de passer par les tracas d'essayer pour installer un logiciel d'évaluation (en supposant que vous êtes un simple utilisateur final). Ne semble pas compétitif pour les petits utilisateurs.

• ** Station de travail Autobahn DX ** le coût de ce produit est tellement prohibitif que vous pourriez probablement acheter 6 copies d'acrobate. Pas vraiment une solution pour l'utilisateur final. Si vous êtes une entreprise, cela peut valoir la peine pour vous.

Linux

• WatchOCR - plus développé, et pratiquement impossible à exécuter sur les distributions Ubuntu modernes
• pdfsandwich - n'est plus développé, pratiquement impossible à exécuter sur les distributions Ubuntu modernes
• ** ABBY LINUX OCR ** - cela devrait être scriptable et semble avoir de bons résultats:

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

Cependant, comme beaucoup de ces autres produits ABBYY qu'ils facturent par page, encore une fois, vous feriez mieux d'essayer de faire fonctionner Acrobat Batch OCR.

• ** Ocrad, GOCR, OCRopus, tesseract, ** - cela peut fonctionner mais il y a quelques problèmes:

  1. Les résultats de l'OCR ne sont pas aussi bons que, par exemple, l'acrobate pour certains d'entre eux (voir le lien ci-dessus).
  2. Aucun des programmes n'accepte un fichier PDF et ne génère un fichier PDF. Vous devez d'abord créer un script et séparer le PDF et exécuter les programmes sur chacun, puis réassembler le fichier au format PDF
  3. Une fois que vous le faites, vous pouvez constater, comme moi, que (tesseract) crée une couche OCR qui est décalée. Donc, si vous recherchez le mot «le», vous obtiendrez un surlignage de la partie du mot à côté de lui.

• DjVu par lots → Convertir en PDF - ne s'y est pas penché, mais semble être une horrible solution ronde.

En ligne

• PDFcubed.com - allez, pas vraiment une solution batch.
• ABBYY Cloud OCR - vous ne savez pas s'il s'agit vraiment d'une solution par lots, de toute façon, vous devez payer à la page et cela pourrait devenir assez coûteux.

Identification des fichiers PDF non OCR

C'est un problème un peu plus facile, qui peut être résolu facilement sous Linux et beaucoup moins sous Windows. J'ai pu coder un script perl en utilisant pdffontpour identifier si les polices sont intégrées pour déterminer quels fichiers ne sont pas OCRed.

"Solutions" actuelles

1. Utilisez un script pour identifier les fichiers PDF non OCR (afin de ne pas réexécuter des milliers de PDF OCR) et copiez-les dans un répertoire temporaire (en conservant l'arborescence de répertoires appropriée), puis utilisez Acrobat sur Windows pour les exécuter en espérant que les plus petits les lots ne plantent pas.

2. utilisez le même script mais utilisez l'un des outils linux ocr pour fonctionner correctement, ce qui risque de nuire à la qualité ocr.

Je pense que je vais essayer # 1, je suis juste trop inquiet pour les résultats des outils Linux OCR (je suppose que personne n'a fait de comparaison) et briser les fichiers et les assembler à nouveau semble un codage inutile si Adobe peut réellement OCR par lots un répertoire sans étouffement.

Si vous voulez une solution entièrement gratuite, vous devrez utiliser un script pour identifier les fichiers PDF non OCR (ou simplement réexécuter sur les fichiers OCR), puis utiliser l'un des outils Linux pour essayer de les OCR. Teseract semble avoir les meilleurs résultats, mais encore une fois, certains de ces outils ne sont pas bien pris en charge dans les versions modernes d'Ubuntu, bien que si vous pouvez le configurer et résoudre le problème que j'avais lorsque la couche d'image ne correspondait pas à la couche de correspondance de texte ( avec tesseract) alors vous auriez une solution assez pratique et encore une fois Linux> Windows.

Avez-vous une solution de travail pour automatiser entièrement les PDF OCR par lots , en ignorant les fichiers déjà OCR conservant le même nom, avec une qualité élevée ? Si oui, j'apprécierais vraiment la contribution.

Script Perl pour déplacer des fichiers non OCR vers un répertoire temporaire. Je ne peux pas garantir que cela fonctionne et doit probablement être réécrit, mais si quelqu'un le fait fonctionner (en supposant que cela ne fonctionne pas) ou fonctionne mieux, faites le moi savoir et je publierai une meilleure version ici.

#!/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\'`;
                }
            }

        }

    }
}

Moi aussi, j'ai cherché un moyen d'OCR par lots de nombreux PDF de manière automatisée, sans beaucoup de chance. En fin de compte, j'ai trouvé une solution réalisable similaire à la vôtre, en utilisant Acrobat avec un script comme suit:

1. Copiez tous les fichiers PDF pertinents dans un répertoire spécifique.

2. Supprimez les PDF contenant déjà du texte (en supposant qu'ils sont déjà OCRd ou déjà texte - pas idéal je sais, mais assez bon pour l'instant).

3. Utilisez AutoHotKey pour exécuter automatiquement Acrobat, sélectionnez le répertoire spécifique et OCR tous les documents, en ajoutant "-ocr" à leur nom de fichier.

4. Déplacez les PDF OCRd vers leur emplacement d'origine, en utilisant la présence d'un fichier "-ocr.pdf" pour déterminer s'il a réussi.

C'est un peu Heath Robinson , mais ça marche plutôt bien.

Je crois que vous devez vous rendre compte qu'ABBYY FineReader est une solution destinée à l'utilisateur final conçue pour fournir une OCR prête à l'emploi rapide et précise.

D'après mon expérience, les projets d'OCR ont des détails significativement différents à chaque fois et il n'y a aucun moyen de créer une âme prête à l'emploi pour chaque cas unique, mais je peux vous proposer des outils plus professionnels qui peuvent faire le travail pour vous:

• Jetez un œil à ABBYY Recognition Server , c'est un produit professionnel pour l'automatisation OCR.

• En ce qui concerne linux, consultez http://ocr4linux.com , c'est un utilitaire de ligne de commande qui peut vous convenir également.

• Pour les tâches plus complexes, ABBYY dispose d'un SDK très flexible comme ABBYY FineReader Engine (hébergé en interne) ou ABBYY Cloud OCR SDK (basé sur Microsoft Azure cloud), qui vous permet de concevoir le traitement OCR comme vous le souhaitez.

Je faisais partie de l'équipe de développement front-end pour le service cloud spécifié ci-dessus et je peux fournir plus d'informations à ce sujet si nécessaire.

Compte tenu de la recherche d'une couche de texte en PDF, je ne peux pas donner de conseil à ce sujet, car cette tâche est un peu à côté de l'OCR qui est ma spécialité, donc je trouve votre approche de l'utilisation d'un script externe très raisonnable. Vous trouverez peut-être cette discussion utile: http://forum.ocrsdk.com/questions/108/check-if-pdf-is-scanned-image-or-contains-text

Sous Linux

Le meilleur moyen et le plus simple de l'utiliser pypdfocrest de ne pas changer le pdf

pypdfocr your_document.pdf

À la fin, vous en aurez un autre your_document_ocr.pdfcomme vous le souhaitez avec du texte consultable. L'application ne change pas la qualité de l'image. Augmente un peu la taille du fichier en ajoutant le texte de superposition.

Pour regrouper les fichiers PDF

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

Si les fichiers PDF sont dans des sous-dossiers:

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

Mise à jour du 3 novembre 2018:

pypdfocrn'est plus pris en charge depuis 2016 et j'ai remarqué des problèmes de non-mentoring. ocrmypdf( module ) fait un travail similaire et peut être utilisé comme ceci:

ocrmypdf in.pdf out.pdf

À installer:

pip install ocrmypdf

ou

apt install ocrmypdf

de sorte que la commande deviendrait

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

J'ai eu un certain succès au début de 2015 en effectuant une OCR par lots entièrement mains libres en utilisant Nuance OmniPage Ultimate sur Windows. Pas gratuit, prix courant 500 $. Utilisez le programme batch "DocuDirect" inclus. Il a une option "Exécuter le travail sans aucune invite" qui semble la réponse directe à votre question d'origine.

J'ai utilisé DocuDirect pour produire un fichier PDF consultable pour chaque image PDF d'entrée (c'est-à-dire non consultable); on peut lui dire de répliquer l'arborescence du répertoire d'entrée dans le dossier de sortie ainsi que les noms des fichiers d'entrée d'origine (presque - voir ci-dessous). Utilise également plusieurs cœurs. La précision était la meilleure des packages que j'ai évalués. Les documents protégés par mot de passe sont ignorés (sans arrêter le travail, sans afficher de boîte de dialogue).

Mise en garde 1: Presque les noms de fichiers d'origine - le suffixe ".PDF" devient ".pdf" (c'est-à-dire, de majuscules en minuscules) car bon, c'est tout de même sur Windows. (Pouah.)

Avertissement 2: aucun fichier journal, donc le diagnostic des fichiers qui échouent pendant la reconnaissance - ce qu'ils font certainement - est de retour sur vous. DocuDirect produira avec plaisir des sorties brouillées comme des pages entières simplement manquantes. J'ai écrit un script python en utilisant le module PyPDF2 pour implémenter une validation brute: tester que le nombre de pages de sortie correspondait au nombre de pages d'entrée. Voir ci-dessous.

Mise en garde 3: Un fichier d'image d'entrée flou et indistinct entraînera le blocage permanent d'OmniPage, sans utiliser de processeur; il ne récupère jamais. Cela fait vraiment dérailler le traitement par lots et je n'ai trouvé aucune solution de contournement. J'ai également signalé cela à Nuance, mais je n'ai rien obtenu.

@Joe a raison sur le fait que le logiciel est mal programmé et documenté. Je note que le cœur d'OmniPage possède une technologie magique de reconnaissance des caractères incroyable, mais la coque extérieure (interface graphique et traitement par lots) est suffisante pour vous faire tirer vos cheveux.

J'approuve la suggestion de @ Joe et @ Kiwi de filtrer les fichiers à l'aide de scripts, afin de ne présenter le package OCR qu'avec des documents images non protégés.

Ma seule affiliation avec Nuance est en tant que client pas exactement satisfait - j'ai un lot de tickets d'assistance non résolus pour le prouver :)

@Joe: Réponse tardive, mais peut-être toujours pertinente. @SuperUser community: J'espère que vous pensez que c'est sur le sujet.

** La mise à jour ** du package successeur est Nuance PowerPDF Advanced, au prix de seulement 150 $. J'ai eu encore plus de succès avec ça, c'est tout aussi précis mais beaucoup plus stable.

Le script python de validation d'arborescence pré / post-OCR suit.

'''
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:])

Vous pouvez envisager l'Autobahn DX d'Aquaforest: http://www.aquaforest.com/en/autobahn.asp

Il est conçu pour traiter des lots de PDF et dispose d'une variété d'options (par exemple, ignorer ou passer des fichiers OCRed) ainsi que des options de traitement intelligent des PDF qui peuvent offrir un meilleur résultat (par exemple, si un PDF contient des pages d'images et d'autres les pages de texte, il peut simplement OCR les pages d'image)

Le Macou Linux:

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

D' ici .