Batch-OCR molti PDF


20

Questo è stato discusso un anno fa qui:

OCR in batch per molti file PDF (non già OCR)?

Esiste un modo per raggruppare PDF OCR che non sono già stati sottoposti a OCR? Questo è, credo, lo stato attuale delle cose che affrontano due questioni:

PDF OCR in batch

finestre

  • Acrobat : questo è il motore ocr più diretto che raggrupperà l'OCR. L'unico problema sembra essere 1) non salterà i file che sono già stati OCR 2) provare a lanciarvi un mucchio di PDF (alcuni vecchi) e vederlo in crash. È un piccolo passeggino. Ti avvertirà ad ogni errore in cui si imbatte (anche se puoi dire al software di non avvisare. Ma di nuovo, muore orribilmente su alcuni tipi di PDF, quindi il tuo chilometraggio può variare.

  • ABBYY FineReader (Batch / Scansnap), Omnipage - Questi devono essere alcuni dei peggiori software programmati conosciuti dall'uomo. Se riesci a scoprire come automatizzare completamente (senza richiesta) l'OCR batch di PDF salvando con lo stesso nome , pubblica qui. Sembra che le uniche soluzioni che ho potuto trovare siano fallite da qualche parte: rinominare, non completamente automatizzato, ecc. Nella migliore delle ipotesi, c'è un modo per farlo, ma la documentazione e la programmazione sono così orribili che non lo scoprirai mai.

  • ABBYY FineReader Engine , ABBYY Recognition Server - Queste sono davvero più soluzioni aziendali, probabilmente faresti meglio a far funzionare Acrobat su una cartella e provare a eliminare i pdf che ti danno errori / crash del programma piuttosto che passare il fastidio di provare per installare un software di valutazione (supponendo che tu sia un semplice utente finale). Non sembra competitivo per i piccoli utenti.

  • ** Stazione di lavoro DX Autobahn ** il costo di questo prodotto è così proibitivo che probabilmente potresti acquistare 6 copie di acrobat. Non proprio una soluzione per l'utente finale. Se sei un setup aziendale, questo potrebbe valerne la pena.

Linux

  • WatchOCR - non più sviluppato e praticamente impossibile da eseguire su moderne distribuzioni Ubuntu
  • pdfsandwich - non più sviluppato, praticamente impossibile da eseguire su moderne distribuzioni Ubuntu
  • ** ABBY LINUX OCR ** - questo dovrebbe essere programmabile da script e sembra avere dei buoni risultati:

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

Tuttavia, come molti di questi altri prodotti ABBYY che caricano sulla pagina, anche in questo caso potrebbe essere meglio provare a far funzionare Acrobat Batch OCR.

  • ** Ocrad, GOCR, OCRopus, tesseract, ** - potrebbero funzionare ma ci sono alcuni problemi:

    1. I risultati OCR non sono così grandi come, per esempio, acrobata per alcuni di questi (vedi link sopra).
    2. Nessuno dei programmi contiene un file PDF e genera un file PDF. Devi creare uno script e suddividere prima il PDF ed eseguire i programmi su ciascuno di essi, quindi riassemblare il file come pdf
    3. Una volta fatto, potresti scoprire, come ho fatto io, che (tesseract) crea un livello OCR che viene spostato. Quindi, se cerchi la parola "the", otterrai un punto culminante della parte della parola accanto ad essa.
  • Batch DjVu → Converti in PDF: non l'ho mai esaminato, ma sembra un'orribile soluzione a tutto tondo.

in linea

  • PDFcubed.com - dai, non proprio una soluzione batch.
  • ABBYY Cloud OCR - non sei sicuro che questa sia davvero una soluzione batch, in entrambi i casi, devi pagare per pagina e questo potrebbe diventare piuttosto costoso.

Identificazione di PDF non OCR

Questo è un problema leggermente più semplice, che può essere risolto facilmente in Linux e tanto meno in Windows. Sono stato in grado di codificare uno script perl usando pdffontper identificare se i caratteri sono incorporati per determinare quali file non sono OCR.


"Soluzioni" attuali

  1. Utilizzare uno script per identificare i PDF non OCR (in modo da non rieseguire più di migliaia di PDF OCR) e copiarli in una directory temporanea (mantenendo l'albero di directory corretto) e quindi utilizzare Acrobat su Windows per eseguire questi sperando che i più piccoli i lotti non si arrestano in modo anomalo.

  2. usa lo stesso script ma ottieni uno degli strumenti ocr di Linux per funzionare correttamente, rischiando la qualità degli ocr.

Penso che proverò # 1, sono solo troppo preoccupato per i risultati degli strumenti OCR di Linux (suppongo che nessuno abbia fatto un confronto) e spezzare i file e ricucirli insieme sembra non è necessario codificare se Adobe può effettivamente raggruppare l'OCR in una directory senza soffocare.

Se vuoi una soluzione completamente gratuita, dovrai usare uno script per identificare i pdf non OCR (o semplicemente eseguire nuovamente quelli OCR), quindi utilizzare uno degli strumenti linux per provare e OCR. Teseract sembra avere i migliori risultati, ma ancora una volta, alcuni di questi strumenti non sono supportati bene nelle versioni moderne di Ubuntu, anche se se riesci a configurarlo e risolvere il problema che ho avuto in cui il livello dell'immagine non corrisponde al livello di corrispondenza del testo ( con tesseract) allora avresti una soluzione abbastanza praticabile e ancora una volta Linux> Windows.


Hai una soluzione funzionante per automatizzare completamente, batch di PDF OCR , saltando i file già OCR mantenendo lo stesso nome, con alta qualità ? In tal caso, apprezzerei molto l'input.


Script Perl per spostare i file non OCR in una directory temporanea. Non posso garantire che funzioni e probabilmente debba essere riscritto, ma se qualcuno lo fa funzionare (supponendo che non funzioni) o funziona meglio, fammi sapere e pubblicherò una versione migliore qui.


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

        }

    }
}

Ciao, potresti condividere lo script di Windows "per identificare i PDF non OCR (...) e copiarli in una directory temporanea (mantenendo l'albero della directory corretto)? Grazie in anticipo;)
Erb

@David ok va bene. Ti avverto che potrebbe non funzionare correttamente la prima volta. Questo non danneggerà affatto i tuoi pdf (copia solo, non tocca gli originali) ma ciò che intendo è che potresti dover modificare lo script. Se conosci il perl sarebbe un gioco da ragazzi, se non fammi sapere, o potresti essere in grado di eseguire il debug da solo e rendere necessarie le modifiche minori.
Joe,

Grazie molto. Proverò a farlo funzionare (anche se sono nuovo con Perl). Grazie.
Erb,

Forse un'altra idea in Windows (ha funzionato in XP)? L'ho usato in passato per "rimuovere da una cartella (con le sottocartelle) tutti i file pdf che non hanno password". L'idea era di mantenere tutti i file pdf protetti da password. Copia con Syncback freeware tutto il pdf (con relative sottocartelle) in una nuova cartella (C: \ 5 \ "). Aggiungi pdftotext.exe e questo file di testo rinominato in del_pdf_no_password.bat. Il suo contenuto:" FOR / RC: \ 5 \% % x IN (* .PDF) DO (pdftotext %% x NUL && DEL %% x) "dove" C: \ 5 \ "è la cartella da modificare. Quindi avviare pdftotext.exe e solo il file .bat.
Erb,

Maggiori dettagli: dovrai rimuovere spazi vuoti (+ caratteri speciali come "," ...) all'interno di qualsiasi nome di cartella con un rinominatore freeware (come per esempio: alternativeto.net/software/renamer ). Altrimenti non funzionerà per tutte le sottocartelle! Ps: non ho scritto questa sceneggiatura (sono stato aiutato da qualcuno nel ... 2004!)
Erb,

Risposte:


3

Anch'io ho cercato un modo per eseguire l'OCR batch di molti PDF in modo automatizzato, senza molta fortuna. Alla fine ho trovato una soluzione praticabile simile alla tua, usando Acrobat con uno script come segue:

  1. Copia tutti i PDF pertinenti in una directory specifica.

  2. Rimuovi i PDF che già contengono testo (supponendo che siano già OCRd o già testo - non l'ideale lo so, ma per ora abbastanza buono).

  3. Utilizzare AutoHotKey per eseguire automaticamente Acrobat, selezionare la directory specifica e OCR tutti i documenti, aggiungendo "-ocr" al loro nome file.

  4. Spostare i PDF OCRd nella loro posizione originale, usando la presenza di un file "-ocr.pdf" per determinare se ha avuto successo.

È un po ' Heath Robinson , ma in realtà funziona abbastanza bene.


Perché è necessario utilizzare AutoHotKey se Acrobat eseguirà già il batch ocr di una directory? Se sei preoccupato di ripetere il processo se acrobat si arresta in modo anomalo, il timestamp del file modificato ti dirà da dove eri rimasto. Se si desidera conservare gli originali, è sufficiente copiare la directory. Se vuoi solo -ocr alla fine, puoi semplicemente fare un cambio di nome batch dopo aver finito.
Joe,

1
Ciao, per fortuna potresti condividere come fai i punti 2. e 3. in Windows? Grazie in anticipo;)
Erb

2

Credo che sia necessario rendersi conto che ABBYY FineReader è una soluzione per l'utente finale progettata per fornire un OCR immediato e preciso.

Sulla base della mia esperienza, i progetti OCR presentano ogni volta dettagli significativamente diversi e non c'è modo di creare un'anima pronta all'uso per ogni caso unico. Ma posso suggerirti strumenti più professionali che possono fare il lavoro per te:

  • Dai un'occhiata a ABBYY Recognition Server , questo è un prodotto professionale per l'automazione OCR.

  • Quando si tratta di Linux, dai un'occhiata a http://ocr4linux.com , è un'utilità della riga di comando che potrebbe adattarsi anche a te.

  • Per attività più complesse ABBYY ha un SDK molto flessibile come ABBYY FineReader Engine (ospitato internamente) o ABBYY Cloud OCR SDK (basato sul cloud Microsoft Azure), che ti consente di progettare l'OCR come desideri.

Facevo parte del team di sviluppo front-end per il servizio cloud sopra specificato e, se necessario, posso fornire ulteriori informazioni al riguardo.

Considerando la ricerca di un livello di testo in PDF, non posso dare alcun consiglio a riguardo, perché questa attività è un po 'a parte dell'OCR che è la mia specialità, quindi trovo il tuo approccio all'utilizzo di script esterni molto ragionevole. Forse troverai utile questa discussione: http://forum.ocrsdk.com/questions/108/check-if-pdf-is-scanned-image-or-contains-text


1
Beh, almeno sappiamo che ABBYY manca della documentazione o funzionalità (che si trova in Acrobat) per raggruppare facilmente l'OCR in una cartella di pdf. L'OCR batch semplice di una cartella di documenti non OCR è una funzionalità estremamente desiderata (molto più di alcune delle altre funzionalità di ABBYY). Basta google per scoprire quanto sia enormemente comune questo desiderio, in caso contrario, posso fornire citazioni. Grazie per le altre opzioni, le esaminerò, ma per ora fate sapere a chiunque venga qui in cerca di come completare questo compito MOLTO comune (cita disponibile) che abbiamo sentito dalla bocca del cavallo che ABBYY non può farlo.
Joe,

OCR batch è disponibile in ABBYY FineReader Professional. Nella tua domanda dichiari la necessità di automatizzare completamente l'OCR. Ora hai bisogno solo di un'elaborazione batch. Si prega di essere chiari in ciò che è esattamente necessario.
Nikolay,

Leggere sopra. Ho detto "FACILE OCR batch", "SEMPLICE batch ocr di una cartella". Più avanti: "Se riesci a scoprire come automatizzare completamente (senza richiesta) OCR batch.". È abbastanza ovvio quello che voglio. Quindi, sia chiaro a chiunque visiti questa pagina: * Se si desidera "elaborare in batch" una cartella di file PDF utilizzando un'interfaccia orribile e complicata con opzioni di salvataggio orribili in un intenso processo ad alta intensità di utilizzo , ABBYY potrebbe funzionare per voi * Se si desidera a "EASILY batch OCR", "simple batch ocr" con poca interazione dell'utente come migliaia di altri, come già accade con Acrobat, ABBYY Finereader non fa per te.
Joe,

2

Su Linux

Il modo migliore e più semplice per usarlo pypdfocrnon cambia il pdf

pypdfocr your_document.pdf

Alla fine ne avrai un altro your_document_ocr.pdfnel modo desiderato con testo ricercabile. L'app non modifica la qualità dell'immagine. Aumenta un po 'la dimensione del file aggiungendo il testo di sovrapposizione.

Per raggruppare i pdf

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

Se i PDF si trovano in sottocartelle:

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

Aggiornamento 3 novembre 2018:

pypdfocrnon è più supportato dal 2016 e ho notato alcuni problemi a causa del mancato mantenimento. ocrmypdf( modulo ) svolge un lavoro simile e può essere utilizzato in questo modo:

ocrmypdf in.pdf out.pdf

Installare:

pip install ocrmypdf

o

apt install ocrmypdf

così il comando sarebbe diventato

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

1

Ho avuto un certo successo all'inizio del 2015 eseguendo l'OCR batch completamente senza mani usando Nuance OmniPage Ultimate su Windows. Non gratuito, prezzo di listino $ 500. Utilizzare il programma batch "DocuDirect" incluso. Ha un'opzione "Esegui processo senza alcuna richiesta" che sembra la risposta diretta alla domanda originale.

Ho usato DocuDirect per produrre un file PDF ricercabile per ciascun file PDF di immagine di input (ovvero non ricercabile); si può dire di replicare l'albero delle directory di input nella cartella di output e i nomi dei file di input originali (quasi - vedi sotto). Utilizza anche più core. L'accuratezza era il migliore dei pacchetti che ho valutato. I documenti protetti da password vengono ignorati (senza interrompere il lavoro, senza mostrare una finestra di dialogo).

Avvertenza 1: quasi i nomi dei file originali - il suffisso ".PDF" diventa ".pdf" (ovvero, da maiuscolo a minuscolo) perché, ehi, è lo stesso su Windows. (Ugh.)

Avvertenza 2: nessun file di registro in modo da diagnosticare quali file falliscono durante il riconoscimento - cosa che sicuramente fanno - è di nuovo a te. DocuDirect produrrà felicemente output confusi come pagine intere semplicemente mancanti. Ho scritto uno script Python usando il modulo PyPDF2 per implementare una validazione grezza: test che il conteggio delle pagine di output corrispondesse al conteggio delle pagine di input. Vedi sotto.

Avvertenza 3: un file di immagine di input sfocato e indistinto farà in modo che OmniPage si blocchi per sempre, senza utilizzare alcuna CPU; non si riprende mai. Questo fa davvero deragliare l'elaborazione batch e non ho trovato soluzioni alternative. Ho anche segnalato questo a Nuance, ma non sono arrivato da nessuna parte.

@Joe ha ragione sul fatto che il software sia mal programmato e documentato. Noto che il nucleo di OmniPage ha un'incredibile tecnologia magica di riconoscimento dei personaggi, ma il guscio esterno (GUI ed elaborazione batch) è sufficiente per farti strappare i capelli.

Approvo il suggerimento di @ Joe e @ Kiwi di schermare i file usando gli script, in modo da presentare il pacchetto OCR solo con documenti di immagine non protetti.

La mia unica affiliazione con Nuance è come cliente non esattamente soddisfatto - ho una serie di ticket di supporto non risolti per dimostrarlo :)

@Joe: risposta tardiva, ma forse ancora rilevante. @SuperUser community: spero che questo sia sul tema.

** Aggiornamento ** Il pacchetto successivo è Nuance PowerPDF Advanced, prezzo di listino a soli $ 150. Ho avuto un successo ancora migliore con questo, è altrettanto preciso ma molto più stabile.

Segue lo script python di validazione dell'albero pre / post-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:])

Ho appena visto il tuo aggiornamento. Lo proverò. Spero che l'OCR sia silenzioso e senza crash! (Wow! 1 GB di download del file!)
Erb

0

Potresti prendere in considerazione l'Autostrada DX di Aquaforest: http://www.aquaforest.com/en/autobahn.asp

È progettato per elaborare batch di PDF e ha una varietà di opzioni (ad es. Salta o pass-through file OCRed) nonché opzioni per il trattamento intelligente dei PDF che possono offrire un risultato migliore (ad es. Se un PDF ha alcune pagine di immagini e alcune pagine di testo, può solo OCR le pagine delle immagini)


Se sei affiliato a quel prodotto, ti preghiamo di dirlo esplicitamente modificando la tua domanda.
Slhck,

0

Su Maco Linux:

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

Da qui .

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.