Vai al contenuto principale
Questo scenario viene utilizzato per elaborare documenti cartacei e salvarli in un archivio digitale, in particolare per creare archivi di contratti, documentazione di progetto, fatture, certificati e così via. In questo scenario di elaborazione, i documenti cartacei vengono convertiti in copie digitali non modificabili che contengono tutte le informazioni del documento in un formato ricercabile. Di conseguenza, le copie digitali dei documenti possono essere facilmente reperite in un archivio elettronico tramite ricerca full-text, è possibile copiare segmenti di testo del documento e inviare i documenti tramite e-mail o stamparli. Per creare una copia digitale, il documento deve innanzitutto passare attraverso diverse fasi di elaborazione, ciascuna delle quali presenta caratteristiche specifiche:
  1. Preelaborazione delle immagini acquisite tramite scansione
Le immagini acquisite tramite scansione possono richiedere una certa preelaborazione prima del riconoscimento, ad esempio se i documenti scansionati contengono rumore di fondo, testo inclinato, colori invertiti, margini neri, orientamento errato o risoluzione non corretta.
  1. Riconoscimento simultaneo di grandi volumi di documenti
Per estrarre i dati di testo da un documento, questo deve essere riconosciuto. Quando si elaborano grandi volumi di documenti, l’elaborazione simultanea dei documenti può risultare utile. In questo caso, il carico di lavoro relativo all’analisi e al riconoscimento può essere distribuito tra i core del processore, velocizzando così l’elaborazione.
  1. Esportazione in un formato di archiviazione
Il documento riconosciuto viene salvato in un formato di archiviazione appropriato. I formati più pratici per l’archiviazione dei documenti sono PDF, PDF/A, PDF e PDF/A con MRC. Quando si salva in questi formati, è possibile utilizzare una modalità in cui il testo viene posizionato sotto l’immagine del documento: ciò consente di preservare completamente la formattazione del documento e di eseguire ricerche full-text. Le impostazioni MRC consentono di ridurre significativamente le dimensioni del file senza perdita di qualità visiva. Inoltre, quando si salva in formato PDF, è possibile personalizzare le impostazioni di sicurezza del documento per proteggerlo da visualizzazione e stampa non autorizzate.

​
Implementazione dello scenario

Gli esempi di codice forniti in questo argomento sono specifici per Windows.
Di seguito è riportata una descrizione dettagliata del metodo consigliato per utilizzare ABBYY FineReader Engine 12 per creare copie digitali dei documenti da archiviare. Il metodo proposto usa impostazioni di elaborazione particolarmente adatte a questo scopo. In questa implementazione, la fase di scansione del documento viene omessa. Per suggerimenti su come implementare la scansione, consulta la sezione Ulteriore ottimizzazione per attività specifiche riportata di seguito.
Per iniziare a lavorare con ABBYY FineReader Engine, è necessario creare l’oggetto Engine. L’oggetto Engine è l’oggetto di livello più alto nella gerarchia degli oggetti di ABBYY FineReader Engine e fornisce varie impostazioni globali, alcuni metodi di elaborazione e metodi per la creazione degli altri oggetti.Per creare l’oggetto Engine, è possibile utilizzare la funzione InitializeEngine. Vedere anche altri modi per caricare l’oggetto Engine (Win).

​
C#

public class EngineLoader : IDisposable
{
    public EngineLoader()
    {
        // Inizializzare queste variabili con il percorso completo di FREngine.dll, il proprio Customer Project ID,
        // e, se applicabile, il percorso del file token della licenza online e la password della licenza online
        string enginePath = "";
        string customerProjectId = "";
        string licensePath = "";
        string licensePassword = "";
        // Caricare la libreria FREngine.dll
        dllHandle = LoadLibraryEx(enginePath, IntPtr.Zero, LOAD_WITH_ALTERED_SEARCH_PATH);
           
        try
        {
            if (dllHandle == IntPtr.Zero)
            {
                throw new Exception("Impossibile caricare " + enginePath);
            }
            IntPtr initializeEnginePtr = GetProcAddress(dllHandle, "InitializeEngine");
            if (initializeEnginePtr == IntPtr.Zero)
            {
                throw new Exception("Impossibile trovare la funzione InitializeEngine");
            }
            IntPtr deinitializeEnginePtr = GetProcAddress(dllHandle, "DeinitializeEngine");
            if (deinitializeEnginePtr == IntPtr.Zero)
            {
                throw new Exception("Impossibile trovare la funzione DeinitializeEngine");
            }
            IntPtr dllCanUnloadNowPtr = GetProcAddress(dllHandle, "DllCanUnloadNow");
            if (dllCanUnloadNowPtr == IntPtr.Zero)
            {
                throw new Exception("Impossibile trovare la funzione DllCanUnloadNow");
            }
            // Convertire i puntatori in delegati
            initializeEngine = (InitializeEngine)Marshal.GetDelegateForFunctionPointer(
                initializeEnginePtr, typeof(InitializeEngine));
            deinitializeEngine = (DeinitializeEngine)Marshal.GetDelegateForFunctionPointer(
                deinitializeEnginePtr, typeof(DeinitializeEngine));
            dllCanUnloadNow = (DllCanUnloadNow)Marshal.GetDelegateForFunctionPointer(
                dllCanUnloadNowPtr, typeof(DllCanUnloadNow));
            // Chiamare la funzione InitializeEngine
            // passando il percorso del file della licenza online e la password della licenza online
            int hresult = initializeEngine(customerProjectId, licensePath, licensePassword, 
                "", "", false, ref engine);
            Marshal.ThrowExceptionForHR(hresult);
        }
        catch (Exception)
        {
            // Liberare la libreria FREngine.dll
            engine = null;
            // Eliminare tutti gli oggetti prima della chiamata a FreeLibrary
            GC.Collect();
            GC.WaitForPendingFinalizers();
            GC.Collect();
            FreeLibrary(dllHandle);
            dllHandle = IntPtr.Zero;
            initializeEngine = null;
            deinitializeEngine = null;
            dllCanUnloadNow = null;
            throw;
        }
    }
    // Funzioni di Kernel32.dll
    [DllImport("kernel32.dll")]
    private static extern IntPtr LoadLibraryEx(string dllToLoad, IntPtr reserved, uint flags);
    private const uint LOAD_WITH_ALTERED_SEARCH_PATH = 0x00000008;
    [DllImport("kernel32.dll")]
    private static extern IntPtr GetProcAddress(IntPtr hModule, string procedureName);
    [DllImport("kernel32.dll")]
    private static extern bool FreeLibrary(IntPtr hModule);
    // Funzioni di FREngine.dll
    [UnmanagedFunctionPointer(CallingConvention.StdCall, CharSet = CharSet.Unicode)]
    private delegate int InitializeEngine(string customerProjectId, string licensePath, 
        string licensePassword, string tempFolder, string dataFolder, bool isSharedCPUCoresMode, 
        ref FREngine.IEngine engine);
    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    private delegate int DeinitializeEngine();
    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    private delegate int DllCanUnloadNow();
    // Variabili private
    private FREngine.IEngine engine = null;
    // Handle di FREngine.dll
    private IntPtr dllHandle = IntPtr.Zero;
    private InitializeEngine initializeEngine = null;
    private DeinitializeEngine deinitializeEngine = null;
    private DllCanUnloadNow dllCanUnloadNow = null;
}

​
C++ (COM)

// Inizializzare queste variabili con il percorso di FREngine.dll, il Customer Project ID di FineReader Engine,
// e, se applicabile, il percorso del token della licenza online e la password della licenza online
wchar_t* FreDllPath;
wchar_t* CustomerProjectId;
wchar_t* LicensePath;  // se non si utilizza una licenza online, assegnare stringhe vuote a queste variabili
wchar_t* LicensePassword;
// HANDLE per FREngine.dll
static HMODULE libraryHandle = 0;
// Oggetto globale FineReader Engine
FREngine::IEnginePtr Engine;
void LoadFREngine()
{
    if( Engine != 0 ) {
    // Già caricato
    return;
    }
    // Primo passaggio: caricare FREngine.dll
    if( libraryHandle == 0 ) {
        libraryHandle = LoadLibraryEx( FreDllPath, 0, LOAD_WITH_ALTERED_SEARCH_PATH );
        if( libraryHandle == 0 ) {
            throw L"Errore durante il caricamento di ABBYY FineReader Engine";
        }
    }
    // Secondo passaggio: ottenere l'oggetto Engine
    typedef HRESULT ( STDAPICALLTYPE* InitializeEngineFunc )( BSTR, BSTR, BSTR, BSTR, 
        BSTR, VARIANT_BOOL, FREngine::IEngine** );
    InitializeEngineFunc pInitializeEngine =
    ( InitializeEngineFunc )GetProcAddress( libraryHandle, "InitializeEngine" );
    if( pInitializeEngine == 0 || pInitializeEngine( CustomerProjectId, LicensePath, 
        LicensePassword, L"", L"", VARIANT_FALSE, &Engine ) != S_OK ) {
    UnloadFREngine();
    throw L"Errore durante il caricamento di ABBYY FineReader Engine";
    }
}
ABBYY FineReader Engine consente di caricare tutte le impostazioni di elaborazione più adatte a questo scenario utilizzando il metodo LoadPredefinedProfile dell’oggetto Engine. Questo metodo accetta come parametro di input il nome del profilo. Per ulteriori informazioni, vedere Working with Profiles.ABBYY FineReader Engine supporta 2 varianti di impostazioni per questo scenario:

Nome del profilo

Descrizione

DocumentArchiving_Accuracy

Le impostazioni sono state ottimizzate per la precisione:

  • Consente di rilevare la massima quantità di testo in un’immagine, incluso il testo incorporato nell’immagine.
  • La sintesi completa della struttura logica del documento non viene eseguita.
Il profilo non è destinato alla conversione di un documento in RTF, DOCX o PDF di solo testo. A tale scopo, usare i profili di conversione dei documenti.

DocumentArchiving_Speed

Le impostazioni sono state ottimizzate per la velocità di elaborazione:

  • Consente di rilevare la massima quantità di testo in un’immagine, incluso il testo incorporato nell’immagine.
  • La correzione dell’inclinazione non viene eseguita.
  • La sintesi completa della struttura logica del documento non viene eseguita.
  • I processi di analisi e riconoscimento del documento vengono accelerati.
Il profilo non è destinato alla conversione di un documento in RTF, DOCX o PDF di solo testo. A tale scopo, usare i profili di conversione dei documenti.

​
C#

// Carica un profilo predefinito
engine.LoadPredefinedProfile("DocumentArchiving_Accuracy");

​
C++ (COM)

// Carica un profilo predefinito
Engine->LoadPredefinedProfile( L"DocumentArchiving_Accuracy" );
Se si desidera modificare le impostazioni di elaborazione, usare gli oggetti Parameter appropriati. Per ulteriori informazioni, vedere Ulteriore ottimizzazione per attività specifiche.
ABBYY FineReader Engine fornisce l’oggetto FRDocument, che consente di elaborare documenti multipagina. L’uso di questo oggetto consente di preservare l’organizzazione logica del documento.Per caricare e preelaborare le immagini di un singolo documento, è necessario creare l’oggetto FRDocument e aggiungervi le immagini. È possibile procedere in uno dei modi seguenti:

​
C#

// Crea l'oggetto FRDocument da un file immagine
FREngine.IFRDocument frDocument = engine.CreateFRDocumentFromImage( "C:\\MyImage.tif", null );

​
C++ (COM)

// Crea l'oggetto FRDocument da un file immagine
FREngine::IFRDocumentPtr frDocument = Engine->CreateFRDocumentFromImage( L"C:\\MyImage.tif", 0 );
Per riconoscere un documento, si consiglia di utilizzare i metodi di analisi e riconoscimento dell’oggetto FRDocument. Questo oggetto mette a disposizione un’ampia gamma di metodi per l’analisi, il riconoscimento e la sintesi del documento. Il metodo più pratico, che consente di eseguire analisi, riconoscimento e sintesi del documento con una sola chiamata, è Process. Inoltre, sfrutta nel modo più efficiente le funzionalità di elaborazione simultanea dei sistemi multiprocessore e multicore. Tuttavia, è anche possibile eseguire in sequenza il pretrattamento, l’analisi, il riconoscimento e la sintesi utilizzando i metodi Preprocess, Analyze, Recognize e Synthesize.

​
C#

// Analizza, riconosci e sintetizza il documento
// Non sono necessari parametri aggiuntivi perché sono impostati dal profilo di elaborazione
frDocument.Process( null );

​
C++ (COM)

// Analizza, riconosci e sintetizza il documento
// Non sono necessari parametri aggiuntivi perché sono impostati dal profilo di elaborazione
frDocument->Process( 0 );
Per salvare un documento riconosciuto, è possibile utilizzare il metodo Export dell’oggetto FRDocument, specificando la costante FileExportFormatEnum come uno dei parametri. In questo scenario, è possibile salvare il documento, ad esempio, in formato PDF utilizzando MRC con la modalità di esportazione PEM_ImageOnText (proprietà TextExportMode dell’oggetto PDFExportParams). È possibile modificare i parametri di esportazione predefiniti utilizzando l’oggetto di esportazione corrispondente. Per ulteriori informazioni, vedere Ulteriore ottimizzazione per attività specifiche qui sotto.Dopo aver terminato di lavorare con l’oggetto FRDocument, rilasciare tutte le risorse utilizzate da questo oggetto. Utilizzare il metodo IFRDocument::Close.

​
C#

// Salva un documento riconosciuto in un formato di archiviazione (ad esempio, PDF)
// Crea un oggetto PDFExportParams
FREngine.PDFExportParams exportParams = engine.CreatePDFExportParams();
// Imposta i parametri necessari
exportParams.MRCMode = FREngine.PDFMRCModeEnum.MRC_Auto;
exportParams.TextExportMode = FREngine.PDFExportModeEnum.PEM_ImageOnText;
// Usa i parametri durante l'esportazione
frDocument.Export( "C:\\MyText.pdf", FREngine.FileExportFormatEnum.FEF_PDF, exportParams );
// Rilascia l'oggetto FRDocument
frDocument.Close();

​
C++ (COM)

// Salva un documento riconosciuto in un formato di archiviazione (ad esempio, PDF)
// Crea un oggetto PDFExportParams
FREngine::IPDFExportParamsPtr params = Engine->CreatePDFExportParams();
// Imposta i parametri necessari
params->MRCMode = FREngine::MRC_Auto;
params->TextExportMode = FREngine::PEM_ImageOnText;
// Usa i parametri durante l'esportazione
frDocument->Export(L"C:\\MyText.pdf", FREngine::FEF_PDF, params);
// Rilascia l'oggetto FRDocument
frDocument->Close();
Dopo aver terminato il lavoro con ABBYY FineReader Engine, è necessario scaricare l’oggetto Engine. A tale scopo, utilizzare la funzione esportata DeinitializeEngine.

​
C#

public class EngineLoader : IDisposable
{
    // Scarica FineReader Engine
    public void Dispose()
    {
        if (engine == null)
        {
            // Engine non è stato caricato
            return;
        }
        engine = null;
        // Eliminazione di tutti gli oggetti prima della chiamata a FreeLibrary
        GC.Collect();
        GC.WaitForPendingFinalizers();
        GC.Collect();
        int hresult = deinitializeEngine();
 
        hresult = dllCanUnloadNow();
        if (hresult == 0)
        {
            FreeLibrary(dllHandle);
        }
        dllHandle = IntPtr.Zero;
        initializeEngine = null;
        deinitializeEngine = null;
        dllCanUnloadNow = null;
        // genera l'eccezione dopo la pulizia
        Marshal.ThrowExceptionForHR(hresult);
    }
    // Funzioni di Kernel32.dll
    [DllImport("kernel32.dll")]
    private static extern IntPtr LoadLibraryEx(string dllToLoad, IntPtr reserved, uint flags);
    private const uint LOAD_WITH_ALTERED_SEARCH_PATH = 0x00000008;
    [DllImport("kernel32.dll")]
    private static extern IntPtr GetProcAddress(IntPtr hModule, string procedureName);
    [DllImport("kernel32.dll")]
    private static extern bool FreeLibrary(IntPtr hModule);
    // Funzioni di FREngine.dll
    [UnmanagedFunctionPointer(CallingConvention.StdCall, CharSet = CharSet.Unicode)]
    private delegate int InitializeEngine( string customerProjectId, string LicensePath, string LicensePassword, , , , ref FREngine.IEngine engine);
    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    private delegate int DeinitializeEngine();
    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    private delegate int DllCanUnloadNow();
    // Variabili private
    private FREngine.IEngine engine = null;
    // Handle di FREngine.dll
    private IntPtr dllHandle = IntPtr.Zero;
    private InitializeEngine initializeEngine = null;
    private DeinitializeEngine deinitializeEngine = null;
    private DllCanUnloadNow dllCanUnloadNow = null;
}

​
C++ (COM)

void UnloadFREngine()
{
 if( libraryHandle == 0 ) {
  return;
 }
 // Rilascia l'oggetto Engine
 Engine = 0;
 // Deinizializza FineReader Engine
 typedef HRESULT ( STDAPICALLTYPE* DeinitializeEngineFunc )();
 DeinitializeEngineFunc pDeinitializeEngine =
  ( DeinitializeEngineFunc )GetProcAddress( libraryHandle, "DeinitializeEngine" );
 if( pDeinitializeEngine == 0 || pDeinitializeEngine() != S_OK ) {
  throw L"Errore durante lo scaricamento di ABBYY FineReader Engine";
 }
 // Ora è possibile liberare in sicurezza la libreria FREngine.dll
 FreeLibrary( libraryHandle );
 libraryHandle = 0;
}

​
Risorse richieste

È possibile utilizzare il file FREngineDistribution.csv per creare automaticamente un elenco dei file necessari al funzionamento dell’applicazione. Per l’elaborazione in questo scenario, selezionare nella colonna 5 (RequiredByModule) i seguenti valori: Core Core.Resources Opening Opening, Processing Processing Processing.OCR Processing.OCR, Processing.ICR Processing.OCR.NaturalLanguages Processing.OCR.NaturalLanguages, Processing.ICR.NaturalLanguages Export Export, Processing Export.Pdf Export.Pdf, Opening.Pdf Se si modifica lo scenario standard, aggiornare di conseguenza i moduli richiesti. È inoltre necessario specificare le lingue dell’interfaccia, le lingue di riconoscimento ed eventuali funzionalità aggiuntive utilizzate dall’applicazione (ad esempio Opening.PDF, se è necessario aprire file PDF, oppure Processing.OCR.CJK, se è necessario riconoscere testi nelle lingue CJK). Per ulteriori dettagli, vedere Working with the FREngineDistribution.csv File.

​
Ulteriori ottimizzazioni per attività specifiche

Di seguito è riportata una panoramica degli argomenti della Guida che contengono informazioni aggiuntive sulla personalizzazione delle impostazioni nelle varie fasi dell’elaborazione dei documenti:
  • Scansione - solo per Windows
    • Scansione
      Descrizione dello scenario di ABBYY FineReader Engine per la scansione di documenti.
  • Riconoscimento
  • Riconoscere il testo scritto a mano
    I profili DocumentArchiving_*** non includono il riconoscimento del testo manoscritto o scritto in stampatello. Se è necessario riconoscere il testo scritto a mano, imposta su TRUE la proprietà DetectHandwritten dell’oggetto PageAnalysisParams.
  • Oggetto PageProcessingParams
    Questo oggetto consente di personalizzare i parametri di analisi e riconoscimento. Tramite questo oggetto, è possibile specificare quali caratteristiche dell’immagine e del testo devono essere rilevate (immagine invertita, orientamento, codici a barre, lingua di riconoscimento, margine di errore del riconoscimento).
  • Oggetto SynthesisParamsForPage
    Questo oggetto comprende i parametri responsabili del ripristino della formattazione della pagina durante la sintesi.
  • Oggetto SynthesisParamsForDocument
    Questo oggetto consente di personalizzare la sintesi del documento, ripristinandone la struttura e la formattazione.
  • Oggetto MultiProcessingParams - Implementato per Linux e Windows
    L’elaborazione simultanea può risultare utile quando si deve elaborare un numero elevato di immagini. In questo caso, il carico di elaborazione viene distribuito tra i core del processore durante l’apertura e la preelaborazione delle immagini, l’analisi del layout, il riconoscimento e l’esportazione, consentendo di velocizzare l’elaborazione.
    Le modalità di lettura (simultanea o sequenziale) vengono impostate tramite la proprietà MultiProcessingMode, mentre la proprietà RecognitionProcessesCount controlla il numero di processi che possono essere avviati.
  • Esportazione
    • Ottimizzazione dei parametri di esportazione
      Personalizzazione dell’esportazione dei documenti tramite oggetti dei parametri di esportazione.
    • Oggetto PDFExportParams
      Questo oggetto consente di ottimizzare l’esportazione in PDF (PDF/A) con pochi parametri.
    • Per personalizzare la modalità di esportazione nel formato PDF (PDF/A), utilizzare la proprietà TextExportMode dell’oggetto PDFExportParams e, per personalizzare le impostazioni MRC, la proprietà MRCMode.
    • Inoltre, è possibile personalizzare le impostazioni di esportazione delle immagini per garantire un’elaborazione più rapida, ridurre ulteriormente le dimensioni del file e così via. Ad esempio, è possibile salvare un’immagine a colori come immagine in scala di grigi o in bianco e nero, se ciò è adatto al proprio scenario (utilizzare la proprietà Colority dell’oggetto PDFExportParams).
    • È possibile modificare la risoluzione dell’immagine in modo che la copia elettronica risultante possa essere successivamente stampata su una stampante o visualizzata sullo schermo di un computer; in alternativa, è possibile selezionare una bassa risoluzione che consenta solo la lettura del testo e produca una qualità grafica molto scarsa (utilizzare le proprietà Resolution e ResolutionType dell’oggetto PDFExportParams).
  • Suddivisione in documenti
    • In questo scenario, il lotto di immagini potrebbe dover essere suddiviso in documenti. ABBYY FineReader Engine 12 non supporta la separazione automatica dei documenti. Tuttavia, è possibile usare ABBYY FlexiCapture Engine per implementare la separazione automatica. I documenti possono essere separati, ad esempio, in base al numero di pagine del documento oppure in base alla presenza di pagine con barcode di separazione. Quando si implementa la separazione tramite barcode, è possibile utilizzare lo scenario per l’estrazione dei soli valori di barcode dal documento.

​
Vedi anche

Implementazione degli scenari d’uso di base