To zostało omówione rok temu tutaj:

Batch OCR dla wielu plików PDF (jeszcze nie OCRed)?

Czy jest jakiś sposób na grupowanie plików PDF OCR, które nie zostały jeszcze OCRedowane? Myślę, że jest to obecny stan rzeczy dotyczących dwóch zagadnień:

Partie plików PDF OCR

Windows

• Acrobat - jest to najprostszy silnik ocr, który wysyła OCR. Jedynym problemem wydaje się być 1) nie pomija plików, które zostały już OCRed 2) spróbuj rzucić na to kilka plików PDF (niektóre stare) i oglądać, jak się psuje. To trochę buggy. Ostrzeże Cię przed każdym błędem, na jaki napotka (chociaż możesz nakazać oprogramowaniu, aby nie powiadamiało. Ale znowu, umiera strasznie na niektórych typach plików PDF, więc twój przebieg może się różnić.

• ABBYY FineReader (Batch / Scansnap), Omnipage - To muszą być jedne z najgorzej zaprogramowanych programów znanych człowiekowi. Jeśli możesz dowiedzieć się, jak w pełni zautomatyzować (bez monitowania) partii OCR zapisywania plików PDF o tej samej nazwie, opublikuj tutaj. Wydaje się, że jedyne rozwiązania, które gdzieś znalazłem, zawiodły - zmiana nazwy, brak pełnej automatyzacji itp. W najlepszym razie istnieje sposób, aby to zrobić, ale dokumentacja i programowanie są tak okropne, że nigdy się nie dowiesz.

• ABBYY FineReader Engine , ABBYY Recognition Server - To naprawdę są rozwiązania dla przedsiębiorstw, prawdopodobnie lepiej byłoby po prostu uruchomić program Acrobat w folderze i wypróbować pliki PDF, które powodują błędy / awarię programu, niż męczyć się zainstalować oprogramowanie ewaluacyjne (zakładając, że jesteś prostym użytkownikiem końcowym). Mały użytkownik nie wydaje się konkurencyjny pod względem kosztów.

• ** Stacja robocza Autobahn DX ** koszt tego produktu jest tak wygórowany, że prawdopodobnie można kupić 6 kopii programu Acrobat. Niezupełnie rozwiązanie dla użytkownika końcowego. Jeśli korzystasz z konfiguracji korporacyjnej, może być to dla Ciebie warte.

Linux

• WatchOCR - nie jest już rozwijany i zasadniczo niemożliwy do uruchomienia na nowoczesnych dystrybucjach Ubuntu
• pdfsandwich - już nie rozwinięty, w zasadzie niemożliwy do uruchomienia na nowoczesnych dystrybucjach Ubuntu
• ** ABBY LINUX OCR ** - powinien być skryptowalny i wydaje się mieć dobre wyniki:

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

Jednak, podobnie jak wiele innych produktów ABBYY, które ładują za stronę, lepiej może być próba uruchomienia OCR Acrobat Batch.

• ** Ocrad, GOCR, OCRopus, tesseract, ** - mogą działać, ale jest kilka problemów:

  1. Wyniki OCR nie są tak dobre jak, powiedzmy, akrobata dla niektórych z nich (patrz powyższy link).
  2. Żaden z programów nie pobiera pliku PDF i nie generuje pliku PDF. Musisz najpierw utworzyć skrypt i rozdzielić plik PDF, uruchomić programy dla każdego z nich, a następnie ponownie złożyć plik jako plik pdf
  3. Gdy to zrobisz, możesz odkryć, podobnie jak ja, że ​​(tesseract) tworzy warstwę OCR, która jest przesuwana. Jeśli więc wyszukasz słowo „the”, podświetlisz jego część obok.

• Partia DjVu → Konwertuj na PDF - nie zaglądałem w to, ale wydaje się, że to okropne rozwiązanie.

online

• PDFcubed.com - daj spokój , nie jest to rozwiązanie partii.
• ABBYY Cloud OCR - nie jestem pewien, czy to naprawdę rozwiązanie wsadowe, tak czy inaczej, trzeba płacić za stronę, a to może być dość drogie.

Identyfikowanie plików PDF innych niż OCR

Jest to nieco łatwiejszy problem, który można łatwo rozwiązać w systemie Linux, a tym bardziej w systemie Windows. Byłem w stanie zakodować skrypt perla, pdffontaby określić, czy czcionki są osadzone, aby określić, które pliki nie są OCR.

Obecne „rozwiązania”

1. Użyj skryptu, aby zidentyfikować pliki PDF nieobsługiwane przez OCR (aby nie uruchamiać ponownie tysięcy plików PDF OCRed) i skopiuj je do katalogu tymczasowego (zachowując prawidłowe drzewo katalogów), a następnie użyj programu Acrobat w systemie Windows, aby przejść do tych plików z nadzieją, że mniejsze partie nie ulegają awarii.

2. użyj tego samego skryptu, ale spraw, aby jedno z narzędzi linux ocr działało poprawnie, ryzykując jakość ocr.

Myślę, że wypróbuję # 1, po prostu martwię się zbytnio o wyniki narzędzi Linux OCR (nie sądzę, żeby ktokolwiek dokonał porównania) i rozbicie plików na części i zszycie ich ponownie wydaje się być niepotrzebnym kodowaniem, jeśli Adobe może faktycznie wsadowo OCR katalogu bez zadławienia.

Jeśli chcesz całkowicie darmowego rozwiązania, będziesz musiał użyć skryptu, aby zidentyfikować pliki PDF nieobsługujące OCR (lub po prostu uruchom ponownie OCRed), a następnie użyj jednego z narzędzi linux, aby spróbować je OCR. Teseract wydaje się mieć najlepsze wyniki, ale znowu, niektóre z tych narzędzi nie są dobrze obsługiwane w nowoczesnych wersjach Ubuntu, chociaż jeśli możesz to ustawić i naprawić problem, który miałem, gdy warstwa obrazu nie pasowała do warstwy dopasowywania tekstu ( z tesseract), to miałbyś całkiem realne rozwiązanie i jeszcze raz Linux> Windows.

Czy masz działające rozwiązanie, aby w pełni zautomatyzować, grupować pliki PDF OCR , pomijając już pliki OCR o tej samej nazwie i wysokiej jakości ? Jeśli tak, naprawdę doceniłbym wkład.

Skrypt Perla do przenoszenia plików innych niż OCR do katalogu tymczasowego. Nie mogę zagwarantować, że to zadziała i prawdopodobnie trzeba go przepisać, ale jeśli ktoś sprawi, że będzie działał (zakładając, że nie działa) lub działa lepiej, daj mi znać, a ja opublikuję tutaj lepszą wersję.

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

        }

    }
}

Ja również szukałem sposobu na grupowe OCR wielu plików PDF w sposób zautomatyzowany, bez większego szczęścia. Na koniec wymyśliłem praktyczne rozwiązanie podobne do twojego, używając Acrobata ze skryptem w następujący sposób:

1. Skopiuj wszystkie odpowiednie pliki PDF do określonego katalogu.

2. Usuń pliki PDF, które już zawierają tekst (zakładając, że są już OCRd lub już tekstem - nie jest to idealne, wiem, ale na razie wystarczająco dobre).

3. Użyj AutoHotKey, aby automatycznie uruchomić program Acrobat, wybierz określony katalog i OCR wszystkie dokumenty, dodając „-ocr” do nazwy pliku.

4. Przenieś pliki PDF OCRd z powrotem do ich oryginalnej lokalizacji, używając pliku „-ocr.pdf”, aby ustalić, czy się powiodło.

To trochę Heath Robinson , ale tak naprawdę działa całkiem dobrze.

Uważam, że musisz zdać sobie sprawę, że ABBYY FineReader jest rozwiązaniem dla użytkownika końcowego, zaprojektowanym w celu zapewnienia szybkiego i dokładnego, gotowego do użycia OCR.

Bazując na moim doświadczeniu, projekty OCR za każdym razem mają znacznie inne szczegóły i nie ma możliwości stworzenia gotowego zestawu dla każdego wyjątkowego przypadku, ale mogę zasugerować Ci bardziej profesjonalne narzędzia, które mogą wykonać to za Ciebie:

• Spójrz na ABBYY Recognition Server , jest to profesjonalny produkt do automatyzacji OCR.

• Jeśli chodzi o Linuksa, spójrz na http://ocr4linux.com , to narzędzie wiersza poleceń, które również może ci pasować.

• Do bardziej skomplikowanych zadań ABBYY ma bardzo elastyczne zestawy SDK, takie jak ABBYY FineReader Engine (hostowany wewnętrznie) lub ABBYY Cloud OCR SDK (oparty na chmurze Microsoft Azure), które pozwalają zaprojektować przetwarzanie OCR tak, jak chcesz.

Należałem do zespołu programistów front-end dla usługi w chmurze określonej powyżej i w razie potrzeby mogę podać więcej informacji na jej temat.

Biorąc pod uwagę wyszukiwanie warstwy tekstowej w formacie PDF, nie mogę udzielić żadnej porady na ten temat, ponieważ to zadanie jest nieco poza OCR, co jest moją specjalnością, więc uważam, że twoje podejście do używania zewnętrznego skryptu jest bardzo rozsądne. Być może ta dyskusja okaże się pomocna: http://forum.ocrsdk.com/questions/108/check-if-pdf-is-scanned-image-or-contains-text

W systemie Linux

Najlepszym i najłatwiejszym sposobem na jego użycie pypdfocrnie jest zmiana pliku pdf

pypdfocr your_document.pdf

Na koniec będziesz miał inny your_document_ocr.pdfsposób, w jaki chcesz, z tekstem do przeszukiwania. Aplikacja nie zmienia jakości obrazu. Zwiększa nieco rozmiar pliku, dodając tekst nakładki.

Partie pdf

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

Jeśli pliki PDF znajdują się w podfolderach:

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

Aktualizacja 3 listopada 2018 r .:

pypdfocrnie jest już obsługiwany od 2016 r. i zauważyłem pewne problemy z powodu braku opieki. ocrmypdf( moduł ) wykonuje podobną pracę i może być używany w następujący sposób:

ocrmypdf in.pdf out.pdf

Żeby zainstalować:

pip install ocrmypdf

lub

apt install ocrmypdf

więc rozkaz stałby się

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

Na początku 2015 roku odniosłem pewien sukces, wykonując całkowicie bezdotykowy pakiet OCR przy użyciu Nuance OmniPage Ultimate na Windowsie. Nie za darmo, cena katalogowa 500 USD. Użyj dołączonego programu wsadowego „DocuDirect”. Ma opcję „Uruchom zadanie bez monitów”, która wydaje się bezpośrednią odpowiedzią na twoje pierwotne pytanie.

Użyłem DocuDirect do wygenerowania jednego pliku PDF z możliwością przeszukiwania dla każdego obrazu wejściowego (tzn. Pliku PDF, którego nie można przeszukiwać); można nakazać replikację drzewa katalogu wejściowego w folderze wyjściowym, a także oryginalnych nazw plików wejściowych (prawie - patrz poniżej). Wykorzystuje także wiele rdzeni. Dokładność była najlepsza z ocenionych przeze mnie pakietów. Dokumenty chronione hasłem są pomijane (bez zatrzymywania zadania, bez wyświetlania okna dialogowego).

Zastrzeżenie 1: Prawie oryginalne nazwy plików - sufiks „.PDF” zmienia się na „.pdf” (tj. Od wielkich do małych liter), ponieważ hej, w Windowsie jest tak samo. (Ugh.)

Zastrzeżenie 2: Brak pliku dziennika, więc diagnoza, które pliki zawiodły podczas rozpoznawania - co zdecydowanie robią - powraca. DocuDirect z przyjemnością wygeneruje zniekształcone dane wyjściowe, tak jakby brakowało całych stron. Napisałem skrypt Pythona za pomocą modułu PyPDF2, aby zaimplementować surową walidację: testowanie, czy liczba stron wyjściowych odpowiada liczbie stron wejściowych. Patrz poniżej.

Zastrzeżenie 3: Zamazany, niewyraźny plik obrazu wejściowego spowoduje zawieszenie programu OmniPage na zawsze, bez użycia procesora; po prostu nigdy się nie odzyskuje. To naprawdę wykracza poza przetwarzanie wsadowe i nie znalazłem żadnych obejść. Zgłosiłem to również do Nuance, ale nigdzie nie dotarłem.

@Joe ma rację, że oprogramowanie jest źle zaprogramowane i udokumentowane. Zauważam, że rdzeń OmniPage ma niesamowitą magiczną technologię rozpoznawania znaków, ale zewnętrzna powłoka (GUI i przetwarzanie wsadowe) jest wystarczająca, aby wyciągnąć włosy.

Popieram sugestie @ Joe i @ Kiwi, aby ekranować pliki za pomocą skryptów, aby przedstawić pakiet OCR tylko niezabezpieczonym dokumentom graficznym.

Moje jedyne powiązanie z Nuance to niezupełnie zadowolony klient - mam na to mnóstwo nierozstrzygniętych zgłoszeń do pomocy technicznej :)

@Joe: Późna odpowiedź, ale może wciąż aktualna. Społeczność @SuperUser: Mam nadzieję, że czujesz, że to temat.

** Aktualizacja ** następcą pakietu jest Nuance PowerPDF Advanced, cena katalogowa zaledwie 150 USD. Miałem z tym jeszcze lepszy sukces, jest tak samo dokładny, ale o wiele bardziej stabilny.

Następuje skrypt sprawdzania poprawności drzewa przed / po OCR.

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

Możesz rozważyć Aquaforest's Autobahn DX: http://www.aquaforest.com/en/autobahn.asp

Jest przeznaczony do przetwarzania partii plików PDF i ma wiele opcji (np. Pomijanie lub przekazywanie plików OCRed), a także opcje inteligentnego przetwarzania plików PDF, które mogą oferować lepszy wynik (np. Jeśli plik PDF zawiera niektóre strony obrazu i niektóre strony tekstowe, może po prostu OCR stron obrazkowych)

W dniu Maclub Linux:

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

Od tutaj .