Auch ich habe nach einer Möglichkeit gesucht, viele PDFs automatisiert zu stapeln, ohne viel Glück. Am Ende habe ich eine praktikable Lösung gefunden, die Ihrer ähnelt, indem ich Acrobat mit einem Skript wie folgt verwende:

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

2. Entfernen Sie PDFs, die bereits Text enthalten (vorausgesetzt, sie sind bereits OCRd oder bereits Text - nicht ideal, ich weiß, aber gut genug für jetzt).

3. Verwenden Sie AutoHotkey, um automatisch auszuführen Acrobat, wählen Sie das spezifische Verzeichnis und OCR alle Dokumente, Anhängen "- ocr", um ihren Dateinamen.

4. Verschieben Sie die OCRd-PDFs mithilfe einer "-ocr " wieder an ihren ursprünglichen Speicherort.pdf" - Datei, um festzustellen, ob es erfolgreich war.

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

Ich glaube, Sie brauchen, um zu realisieren, dass ABBYY FineReader ist ein end-user-Lösung entwickelt, um bieten schnelle&genaue out-of-the-box-OCR.

Basierend auf meiner Erfahrung haben OCR-Projekte jedes Mal signifikant unterschiedliche Details, und es gibt keine Möglichkeit, eine sofort einsatzbereite Wiederholung für jeden Einzelfall zu erstellen.Aber ich kann Ihnen professionellere Tools vorschlagen, die die Arbeit für Sie erledigen können:

• Schauen Sie sich ABBYY Recognition Server an, dies ist ein professionelles Produkt für OCR automatisierung.

• Wann kommt linux, anschauen http://ocr4linux.com, es ist ein Befehlszeilen-Dienstprogramm, dass kann passen Sie als gut.

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

Ich war ein Teil des Front-End-Entwicklungsteams für die cloud-Service oben angegeben und kann bei Bedarf weitere Informationen dazu liefern.

In Anbetracht der Suche einer Textebene in PDF kann ich dazu keinen Rat geben,da diese Aufgabe etwas außerhalb von OCR liegt, was meine Spezialität ist, daher finde ich Ihren Ansatz zur Verwendung eines externen Skripts sehr vernünftig. Vielleicht finden Sie diese Diskussion hilfreich: http://forum.ocrsdk.com/questions/108/check-if-pdf-is-scanned-image-or-contains-text

Ich hatte Anfang 2015 einige Erfolge bei der vollständigen praktischen Batch-OCR mit Nuance OmniPage Ultimate unter Windows. Nicht kostenlos, Listenpreis $ 500. Verwenden Sie das mitgelieferte Batch-Programm "DocuDirect". Es hat eine Option "Job ohne Eingabeaufforderungen ausführen", die die direkte Antwort auf Ihre ursprüngliche Frage zu sein scheint.

Ich habe DocuDirect verwendet, um eine durchsuchbare PDF-Datei für jedes Eingabebild (dh eine nicht durchsuchbare) PDF-Datei auszugeben. es kann gesagt werden, den Eingabeverzeichnisbaum im Ausgabeordner als zu replizieren sowie die ursprünglichen Eingabedateinamen (fast - siehe unten). Verwendet auch mehrere Kerne. Die Genauigkeit war das Beste der Pakete, die ich bewertet habe. Passwortgeschützte Dokumente werden übersprungen (ohne den Job zu stoppen, ohne einen Dialog anzuzeigen).

Einschränkung 1: Fast die ursprünglichen Dateinamen-Suffix".PDF" wird ".pdf " (dh von Groß-nach Kleinschreibung), weil hey, es ist alles gleich unter Windows. (Pfui.)

Vorbehalt 2: Keine Protokolldatei, damit diagnostiziert wird, welche Dateien während der Erkennung fehlschlagen - welche sie auf jeden Fall tun - ist wieder auf Sie. DocuDirect wird gerne verstümmelte Ausgaben produzieren, wie ganze Seiten einfach fehlen. Ich habe ein Python-Skript mit dem PyPDF2-Modul geschrieben, um eine grobe Validierung zu implementieren: Testen, ob die Anzahl der Ausgabeseiten mit der Anzahl der Eingabeseiten übereinstimmt. Siehe unten.

Vorbehalt 3: Eine unscharfe, undeutliche Eingabebilddatei führt dazu, dass OmniPage für immer hängt und keine CPU verwendet.es erholt sich einfach nie. Dies entgleist wirklich die Stapelverarbeitung und ich habe keine Problemumgehungen gefunden. Ich auch meldete dies Nuance, kam aber nirgendwohin.

@Joe hat Recht, dass die Software schlecht programmiert und dokumentiert ist. Ich stelle fest, dass der [[12]}Core von OmniPage über eine erstaunliche magische Technologie zur Zeichenerkennung verfügt, aber die äußere Hülle (GUI & Batch-Verarbeitung) reicht aus, um Ihre Haare herauszuziehen.

Ich unterstütze den Vorschlag von @Joe und @Kiwi, Dateien mithilfe von Skripten auszublenden, um das OCR-Paket nur mit ungeschützten Bilddokumenten zu präsentieren.

Meine einzige Zugehörigkeit mit Nuance ist als nicht gerade zufriedener Kunde-ich habe eine Menge ungelöster Support-Tickets, um es zu beweisen:)

@Joe: Späte Antwort, aber vielleicht noch relevant. @SuperUser Community: Ich hoffe, Sie fühlen sich das Thema ist.

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

Pre / post-OCR Baum Validierung Python skript folgt.

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

Unter Linux

Der beste und einfachste Weg ist, pypdfocr zu verwenden, es ändert sich nicht das PDF

pypdfocr your_document.pdf

Am Ende haben Sie ein anderes your_document_ocr.pdf, wie Sie es mit durchsuchbarem Text wollen. Die app ändert nicht die Qualität des Bildes. Erhöht die Größe der Datei ein wenig, indem Sie den Overlay-Text hinzufügen.

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:

pypdfocr wird seither nicht mehr unterstützt 2016 und ich habe einige Probleme bemerkt, weil ich nicht erwähnt wurde. ocrmypdf(modul) macht einen symiliaren Job und kann wie folgt verwendet werden:

ocrmypdf in.pdf out.pdf

Zu installieren:

pip install ocrmypdf

Oder

apt install ocrmypdf

So würde der Befehl

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

Man könnte Aquaforest ' s Autobahn DX betrachten: http://www.aquaforest.com/en/autobahn.asp

Es wurde entwickelt, um Stapel von PDFs zu verarbeiten und verfügt über eine Vielzahl von Optionen (z. B. Überspringen oder Übergeben von OCRed-Dateien) sowie Optionen für die intelligente Behandlung von PDFs, die möglicherweise ein besseres Ergebnis liefern (z. B. wenn ein PDF einige Bildseiten und einige Textseiten hat, kann es nur die Bildseiten OCR)

Auf Mac oder Linux:

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

Von hier.