Dies wurde vor einem Jahr hier diskutiert:

Stapel-OCR für viele PDF-Dateien (noch nicht OCR-fähig)?

Gibt es eine Möglichkeit zum Stapeln von OCR-PDFs, die noch nicht OCR-fähig sind? Ich denke, dies ist der aktuelle Stand der Dinge, die sich mit zwei Problemen befassen:

Stapel-OCR-PDFs

Windows

• Acrobat - Dies ist die direkteste OCR-Engine, mit der sich OCR stapeln lässt. Das einzige Problem scheint zu sein: 1) Es werden keine Dateien übersprungen, die bereits mit OCR versehen wurden. 2) Wirf ein paar PDFs darauf (einige alte) und sieh zu, wie es abstürzt. Es ist ein kleiner Buggy. Es warnt Sie bei jedem aufgetretenen Fehler (obwohl Sie die Software anweisen können, sich nicht zu benachrichtigen). Bei bestimmten PDF-Typen stirbt es jedoch erneut fürchterlich ab, sodass Ihre Laufleistung variieren kann.

• ABBYY FineReader (Batch / Scansnap), Omnipage - Dies müssen einige der schlechtesten programmierten Softwareteile sein, die der Mensch kennt . Wenn Sie herausfinden können, wie Sie die Stapel-OCR von PDFs , die mit demselben Namen gespeichert werden, vollständig automatisieren können (ohne Aufforderung), posten Sie dies bitte hier. Es scheint, dass die einzigen Lösungen, die ich finden konnte, irgendwo fehlgeschlagen sind - Umbenennen, nicht vollautomatisch usw. usw. Bestenfalls gibt es eine Möglichkeit, dies zu tun, aber die Dokumentation und Programmierung sind so schrecklich, dass Sie es nie herausfinden werden.

• ABBYY FineReader Engine , ABBYY Recognition Server - Dies sind wirklich mehr Unternehmenslösungen, wahrscheinlich ist es besser, wenn Sie Acrobat dazu bringen, einen Ordner zu überfliegen und pdfs auszusortieren, die Ihnen Fehler / Abstürze des Programms verursachen, als das mühsame Ausprobieren Evaluierungssoftware installieren (vorausgesetzt, Sie sind ein einfacher Endbenutzer). Scheint für den kleinen Benutzer nicht wettbewerbsfähig zu sein.

• ** Autobahn DX Workstation ** Die Kosten für dieses Produkt sind so unerschwinglich, dass Sie wahrscheinlich 6 Exemplare von Akrobaten kaufen könnten. Nicht wirklich eine Endbenutzerlösung. Wenn Sie ein Unternehmenssetup sind, kann sich dies für Sie lohnen.

Linux

• WatchOCR - nicht mehr entwickelt und auf modernen Ubuntu-Distributionen grundsätzlich nicht lauffähig
• pdfsandwich - nicht mehr entwickelt, auf modernen Ubuntu-Distributionen grundsätzlich nicht lauffähig
• ** ABBY LINUX OCR ** - dies sollte skriptfähig sein und scheint einige gute Ergebnisse zu haben:

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

Wie bei vielen dieser anderen ABBYY-Produkte, die sie pro Seite berechnen, ist es jedoch möglicherweise besser, Acrobat Batch OCR zum Laufen zu bringen.

• ** Ocrad, GOCR, OCRopus, Tesseract, ** - diese können funktionieren, aber es gibt ein paar Probleme:

  1. OCR-Ergebnisse sind für einige von ihnen nicht so gut wie beispielsweise Akrobat (siehe obigen Link).
  2. Keines der Programme nimmt eine PDF-Datei auf und gibt eine PDF-Datei aus. Sie müssen zuerst ein Skript erstellen und die PDF-Datei aufteilen, die Programme über jede einzelne ausführen und dann die Datei als PDF neu zusammenstellen
  3. Wenn Sie dies tun, stellen Sie möglicherweise wie ich fest, dass (tesseract) eine OCR-Ebene erstellt, die verschoben wird. Wenn Sie also nach dem Wort 'the' suchen, erhalten Sie eine Hervorhebung des Teils des Wortes daneben.

• Batch DjVu → In PDF konvertieren - habe es nicht untersucht, aber es scheint eine schreckliche Rundumlösung zu sein.

Online

• PDFcubed.com - komm schon, nicht wirklich eine Batch-Lösung.
• ABBYY Cloud OCR - Sie sind sich nicht sicher, ob dies wirklich eine Batch-Lösung ist, oder nicht. Sie müssen seitenweise bezahlen, was sehr teuer werden kann.

Identifizieren von nicht OCR-fähigen PDFs

Dies ist ein etwas einfacheres Problem, das unter Linux und noch viel weniger unter Windows leicht gelöst werden kann. Ich konnte ein Perl-Skript codieren, pdffontum festzustellen, ob Schriftarten eingebettet sind, um festzustellen, welche Dateien nicht OCR-geschützt sind.

Aktuelle "Lösungen"

1. Verwenden Sie ein Skript, um nicht-OCRed-PDFs zu identifizieren (damit Sie nicht Tausende von OCRed-PDFs erneut ausführen), und kopieren Sie diese in ein temporäres Verzeichnis (wobei die richtige Verzeichnisstruktur beibehalten wird). Verwenden Sie dann Acrobat unter Windows, um diese zu überfliegen, in der Hoffnung, dass die kleinere Chargen stürzen nicht ab.

2. Verwenden Sie dasselbe Skript, aber sorgen Sie dafür, dass eines der Linux Ocr-Tools ordnungsgemäß funktioniert.

Ich denke, ich werde es mit Nummer 1 versuchen. Ich mache mir zu viele Sorgen um die Ergebnisse der Linux-OCR-Tools (ich nehme nicht an, dass jemand einen Vergleich angestellt hat). Es scheint, als würde man die Dateien aufteilen und wieder zusammenfügen unnötige Codierung sein, wenn Adobe tatsächlich ein Verzeichnis stapelweise OCR-fähig macht, ohne daran zu ersticken.

Wenn Sie eine völlig kostenlose Lösung wünschen, müssen Sie ein Skript verwenden, um die nicht-OCR-fähigen PDFs zu identifizieren (oder sie einfach erneut über OCR-fähige PDFs ausführen), und dann eines der Linux-Tools verwenden, um sie zu testen und zu OCRen. Teseract scheint die besten Ergebnisse zu liefern, aber auch hier werden einige dieser Tools in modernen Ubuntu-Versionen nicht gut unterstützt. Wenn Sie es jedoch einrichten und das Problem beheben können, bei dem die Bildebene nicht mit der Textanpassungsebene übereinstimmt ( mit tesseract) hättest du dann eine ziemlich brauchbare lösung und nochmal Linux> Windows.

Haben Sie eine funktionierende Lösung zur vollständigen Automatisierung von OCR-PDFs im Stapelbetrieb , bei der bereits OCR-Dateien mit gleichem Namen in hoher Qualität übersprungen werden ? Wenn ja, würde ich die Eingabe wirklich schätzen.

Perl-Skript zum Verschieben von Nicht-OCR-Dateien in ein temporäres Verzeichnis. Kann nicht garantieren, dass dies funktioniert und muss wahrscheinlich umgeschrieben werden, aber wenn jemand es funktioniert (vorausgesetzt, es funktioniert nicht) oder besser, lass es mich wissen und ich werde hier eine bessere Version posten.

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

        }

    }
}

Auch ich habe nach einer Möglichkeit gesucht, viele PDFs automatisch und ohne viel Glück per Batch-OCR zu erkennen. Am Ende habe ich eine funktionierende Lösung gefunden, die Ihrer ähnlich ist und Acrobat mit einem Skript wie folgt verwendet:

1. Kopieren Sie alle relevanten PDFs in ein bestimmtes Verzeichnis.

2. Entfernen Sie PDF-Dateien, die bereits Text enthalten (vorausgesetzt, sie sind bereits OCR-Dateien oder bereits Text-Dateien - nicht ideal, ich weiß, aber für den Moment gut genug).

3. Verwenden Sie AutoHotKey , um Acrobat automatisch auszuführen, das gewünschte Verzeichnis auszuwählen und alle Dokumente mit OCR zu versehen und "-ocr" an den Dateinamen anzuhängen.

4. Verschieben Sie die OCRd-PDF-Dateien zurück an ihren ursprünglichen Speicherort. Verwenden Sie dazu eine "-ocr.pdf" -Datei, um festzustellen, ob sie erfolgreich waren.

Es ist ein bisschen Heath Robinson , aber eigentlich funktioniert es ziemlich gut.

Ich glaube, Sie müssen erkennen, dass ABBYY FineReader eine Endbenutzerlösung ist, die eine schnelle und genaue OCR-Funktion bietet.

Aufgrund meiner Erfahrung weisen OCR-Projekte jedes Mal deutlich unterschiedliche Details auf, und es gibt keine Möglichkeit, für jeden Einzelfall eine neue Dimension zu schaffen. Aber ich kann Ihnen professionellere Tools vorschlagen, die diese Aufgabe für Sie erledigen können:

• Werfen Sie einen Blick auf ABBYY Recognition Server , dies ist ein professionelles Produkt für die OCR-Automatisierung.

• Wenn es um Linux geht, besuchen Sie http://ocr4linux.com , es ist ein Befehlszeilenprogramm, das auch zu Ihnen passt.

• Für komplexere Aufgaben verfügt ABBYY über sehr flexible SDKs wie ABBYY FineReader Engine ( intern gehostet) oder ABBYY Cloud OCR SDK (basierend auf Microsoft Azure Cloud), mit denen Sie die OCR-Verarbeitung nach Ihren Wünschen gestalten können.

Ich war Teil des Front-End-Entwicklungsteams für den oben angegebenen Cloud-Service und kann bei Bedarf weitere Informationen dazu bereitstellen.

In Anbetracht der Suche nach einer Textebene in PDF kann ich dazu keinen Rat geben, da diese Aufgabe etwas abseits von OCR liegt, was meine Spezialität ist. Daher finde ich Ihren Ansatz, externe Skripte zu verwenden, sehr vernünftig. Vielleicht finden Sie diese Diskussion hilfreich: http://forum.ocrsdk.com/questions/108/check-if-pdf-is-scanned-image-or-contains-text

Unter Linux

Der beste und einfachste Weg, es zu benutzen pypdfocr, ändert das PDF nicht

pypdfocr your_document.pdf

Am Ende haben Sie einen anderen, your_document_ocr.pdfwie Sie es mit durchsuchbarem Text wollen. Die App ändert die Bildqualität nicht. Erhöht die Größe der Datei ein wenig, indem der Overlay-Text hinzugefügt wird.

Zum Stapeln der PDFs

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

Wenn sich die PDFs in Unterordnern befinden:

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

Update 3. November 2018:

pypdfocrwird seit 2016 nicht mehr unterstützt und ich habe einige Probleme festgestellt, weil ich nicht betreut wurde. ocrmypdf( Modul ) erledigt einen ähnlichen Job und kann wie folgt verwendet werden:

ocrmypdf in.pdf out.pdf

Installieren:

pip install ocrmypdf

oder

apt install ocrmypdf

so würde der Befehl werden

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

Ich hatte Anfang 2015 einige Erfolge mit der vollautomatischen Batch-OCR mit Nuance OmniPage Ultimate unter Windows. Nicht frei, Listenpreis $ 500. Verwenden Sie das mitgelieferte Batch-Programm "DocuDirect". Die Option "Job ohne Eingabeaufforderung ausführen" scheint die direkte Antwort auf Ihre ursprüngliche Frage zu sein.

Ich habe DocuDirect verwendet, um eine durchsuchbare PDF-Datei für jede eingegebene (dh nicht durchsuchbare) PDF-Datei auszugeben. Es kann angewiesen werden, den Eingabeverzeichnisbaum im Ausgabeordner sowie die ursprünglichen Eingabedateinamen zu replizieren (fast - siehe unten). Verwendet auch mehrere Kerne. Die Genauigkeit war die beste der von mir bewerteten Pakete. Passwortgeschützte Dokumente werden übersprungen (ohne den Job anzuhalten, ohne einen Dialog anzuzeigen).

Vorsichtsmaßnahme 1: Fast die ursprünglichen Dateinamen - das Suffix ".PDF" wird zu ".pdf" (dh von Groß- zu Kleinbuchstaben), da es unter Windows alle gleich ist. (Pfui.)

Vorsichtsmaßnahme 2: Keine Protokolldatei. Die Diagnose, welche Dateien während der Erkennung fehlerhaft sind - was sie definitiv tun -, liegt nun wieder bei Ihnen. DocuDirect erzeugt gerne verstümmelte Ausgaben wie ganze Seiten, die einfach fehlen. Ich habe ein Python-Skript mit dem PyPDF2-Modul geschrieben, um eine grobe Validierung zu implementieren: Testen, ob die Anzahl der ausgegebenen Seiten mit der Anzahl der eingegebenen Seiten übereinstimmt. Siehe unten.

Vorsichtsmaßnahme 3: Eine unscharfe, undeutliche Eingabebilddatei führt dazu, dass OmniPage für immer hängt und keine CPU verwendet wird. es erholt sich einfach nie. Dadurch wird die Stapelverarbeitung wirklich entgleist, und es wurden keine Problemumgehungen gefunden. Ich habe dies auch Nuance gemeldet, bin aber nicht weitergekommen.

@Joe hat Recht damit, dass die Software schlecht programmiert und dokumentiert ist. Ich stelle fest, dass der Kern von OmniPage über eine erstaunliche Technologie zur Erkennung magischer Zeichen verfügt, aber die äußere Hülle (GUI & Stapelverarbeitung) reicht aus, um Ihnen die Haare herauszuziehen.

Ich unterstütze @ Joes und @ Kiwis Vorschlag, Dateien mithilfe von Skripten auszusortieren, um das OCR-Paket nur mit ungeschützten Bilddokumenten zu präsentieren.

Meine einzige Zugehörigkeit zu Nuance ist ein nicht genau zufriedener Kunde - ich habe eine Reihe ungelöster Support-Tickets, um dies zu beweisen :)

@ Joe: Späte Antwort, aber vielleicht immer noch relevant. @ SuperUser-Community: Ich hoffe, Sie haben das Gefühl, dies ist ein Thema.

** Update ** Nachfolgepaket ist Nuance PowerPDF Advanced, Listenpreis nur $ 150. Ich hatte noch besseren Erfolg damit, es ist genauso genau, aber weitaus stabiler.

Es folgt ein Python-Skript für die Pre- / Post-OCR-Baumvalidierung.

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

Sie könnten Aquaforests Autobahn DX in Betracht ziehen: http://www.aquaforest.com/de/autobahn.asp

Es ist für die Verarbeitung von PDF-Stapeln konzipiert und verfügt über eine Reihe von Optionen (z. B. Überspringen oder Weiterleiten von OCR-Dateien) sowie Optionen für die intelligente Behandlung von PDF-Dateien, die möglicherweise ein besseres Ergebnis liefern (z. B. wenn eine PDF-Datei einige Bildseiten und einige enthält) Textseiten, es können nur die Bildseiten OCR)

Ein Macoder Linux:

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

Von hier .