Vai al contenuto principale
Questo scenario viene utilizzato per estrarre tutti i dati possibili da un documento e memorizzarli in modo strutturato. Il risultato è un file JSON che rappresenta la struttura del documento. Contiene tutti gli oggetti del documento: testo stampato e scritto a mano, tabelle, Barcode, segni di spunta e immagini con la relativa posizione e i rispettivi attributi. Questo formato è ottimale per l’elaborazione successiva, l’archiviazione dei dati in un database o l’integrazione con un’altra applicazione. In questo scenario, un documento attraversa diverse fasi di elaborazione:
  1. Pre-elaborazione di immagini scansionate o foto
Le immagini ottenute tramite uno scanner o una fotocamera digitale potrebbero richiedere alcune correzioni prima di poter essere riconosciute otticamente. Ad esempio, le immagini con disturbi o con righe di testo deformate richiedono alcuni interventi correttivi affinché il riconoscimento ottico abbia esito positivo.
  1. Estrazione strutturata di tutti i dati presenti nel documento
Durante l’analisi del layout, nell’immagine vengono rilevati vari oggetti e raggruppati in blocchi del tipo corrispondente. I blocchi vengono riconosciuti in base alle impostazioni ottimali per il rispettivo tipo. Nel corso della sintesi, la struttura logica del documento viene ricostruita in modo coerente. L’ordine del testo, anche nei layout complessi, viene mantenuto in modo simile a come lo leggerebbe una persona. Questo garantisce che un nuovo riconoscimento dello stesso documento produca lo stesso ordine del testo.
  1. Esportazione in un formato strutturato
Il documento riconosciuto viene salvato in formato JSON o XML.

​
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 estrarre dati dai documenti. Il metodo proposto usa le impostazioni di elaborazione più adatte a questo scopo.
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 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");
            }
            // Conversione dei 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;
            // Eliminazione di 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 riceve come parametro di input il nome del profilo. Per ulteriori informazioni, vedere Working with Profiles.Le impostazioni per questo scenario sono disponibili nel profilo predefinito DataExtraction:
  • L’analisi del layout e il riconoscimento privilegiano l’accuratezza rispetto alla velocità.
  • Rileva tutto il testo presente nell’immagine, incluso il testo scritto a mano e le piccole aree di testo di bassa qualità.
  • Rileva tabelle, segni di spunta e barcode.
  • Viene eseguita la sintesi completa della struttura logica del documento.

​
C#

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

​
C++ (COM)

// Carica un profilo predefinito
Engine->LoadPredefinedProfile( L"DataExtraction" );
Se si desidera modificare le impostazioni di elaborazione, utilizzare i relativi oggetti Parameter. Per ulteriori informazioni, vedere la sezione Additional optimization riportata di seguito.
ABBYY FineReader Engine mette a disposizione l’oggetto FRDocument, che consente di elaborare documenti multipagina. L’uso di questo oggetto permette di preservare l’organizzazione logica del documento, mantenendo il testo e le colonne originali, i font, gli stili e così via.Per caricare e pre-elaborare le immagini di un singolo documento, è necessario creare l’oggetto FRDocument e aggiungervi le immagini. È possibile procedere in uno dei seguenti modi:

​
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 offre un’ampia gamma di metodi per l’analisi, il riconoscimento e la sintesi del documento. Il metodo più pratico, che combina in un’unica operazione analisi, riconoscimento e sintesi del documento, è Process. Inoltre, sfrutta nel modo più efficiente le funzionalità di elaborazione parallela dei sistemi multiprocessore e multicore. In alternativa, è anche possibile eseguire in sequenza preelaborazione, analisi, riconoscimento e sintesi utilizzando i metodi Preprocess, Analyze, Recognize e Synthesize.

​
C#

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

​
C++ (COM)

// Analizza, riconosce 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. È possibile modificare i parametri di esportazione predefiniti utilizzando il corrispondente oggetto di esportazione. Per ulteriori informazioni, consulta Ulteriore ottimizzazione per attività specifiche qui sotto.Una volta terminato l’utilizzo dell’oggetto FRDocument, rilascia tutte le risorse usate da questo oggetto. Utilizza il metodo IFRDocument::Close.

​
C#

// Salva il documento riconosciuto in un formato strutturato
frDocument.Export( "C:\\Data.json", FREngine.FileExportFormatEnum.FEF_JSON, null );
// Rilascia l'oggetto FRDocument
frDocument.Close();

​
C++ (COM)

// Salva il documento riconosciuto in un formato strutturato
frDocument->Export( L"C:\\Data.json", FREngine::FEF_JSON, 0 );
// Rilascia l'oggetto FRDocument
frDocument->Close();
Dopo aver terminato di utilizzare 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;
        // Elimina 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";
 }
 // A questo punto è possibile liberare in sicurezza la libreria FREngine.dll
 FreeLibrary( libraryHandle );
 libraryHandle = 0;
}

​
Risorse necessarie

Puoi usare il file FREngineDistribution.csv per creare automaticamente un elenco dei file necessari al funzionamento della tua applicazione. Per l’elaborazione in questo scenario, seleziona 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 Se modifichi lo scenario standard, aggiorna di conseguenza i moduli richiesti. Devi anche specificare le lingue dell’interfaccia, le lingue di riconoscimento e tutte le funzionalità aggiuntive utilizzate dalla tua applicazione (ad esempio, Opening.PDF se devi aprire file PDF oppure Processing.OCR.CJK se devi riconoscere testi in lingue CJK). Per ulteriori dettagli, consulta Working with the FREngineDistribution.csv File.

​
Ulteriore ottimizzazione per attività specifiche

Di seguito è riportata una panoramica degli argomenti della Guida che contengono informazioni aggiuntive sulla personalizzazione delle impostazioni nelle diverse fasi della conversione di un documento in un formato modificabile:
  • Scansione - solo per Windows
    • Scansione
      Descrizione dello scenario di ABBYY FineReader Engine per la scansione dei documenti.
  • Riconoscimento
    • Ottimizzazione dei parametri di pre-elaborazione, analisi, riconoscimento e sintesi
      Personalizzazione dell’elaborazione dei documenti mediante oggetti Parameter per l’analisi, il riconoscimento e la sintesi.
    • Oggetto PageProcessingParams
      Questo oggetto consente di personalizzare i parametri di analisi e riconoscimento. Utilizzandolo, è possibile indicare quali caratteristiche dell’immagine e del testo devono essere rilevate (immagine invertita, orientamento, Barcode, lingua di riconoscimento, margine di errore del riconoscimento).
    • Oggetto SynthesisParamsForPage
      Questo oggetto include i parametri responsabili del ripristino della formattazione di una pagina durante la sintesi.
    • Oggetto SynthesisParamsForDocument
      Questo oggetto consente di personalizzare la sintesi del documento: il ripristino della sua struttura e 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 pre-elaborazione delle immagini, l’analisi del layout, il riconoscimento e l’esportazione, consentendo di velocizzare l’elaborazione.
      Le modalità di elaborazione (simultanea o consecutiva) vengono impostate tramite la proprietà MultiProcessingMode. La proprietà RecognitionProcessesCount controlla il numero di processi che possono essere avviati.
  • Esportazione

​
Vedi anche

Implementazione degli scenari di utilizzo di base