Vai al contenuto principale
Questo scenario consente di estrarre il corpo del testo di un documento e i testi presenti su loghi, sigilli e su qualsiasi altro elemento diverso dal corpo del testo. L’ordine naturale del testo, “come lo leggerebbe una persona”, viene preservato. È quindi possibile passare i documenti ai motori di elaborazione del linguaggio naturale (NLP) in uso nel proprio ambiente, ad esempio per riassumerli rapidamente, cercare informazioni sensibili o sottoporli a un’analisi del sentiment. Per estrarre il testo principale del documento, i file immagine ottenuti tramite scansione o salvati in formato elettronico passano in genere attraverso diverse fasi di elaborazione, ciascuna con le proprie peculiarità:
  1. Pre-elaborazione delle immagini scansionate o delle foto
Le immagini scansionate possono richiedere una certa pre-elaborazione prima del riconoscimento, ad esempio se i documenti scansionati contengono rumore di fondo, testo inclinato, colori invertiti, margini neri, orientamento errato o una risoluzione non corretta.
  1. Riconoscimento della massima quantità possibile di testo nell’immagine di un documento
Il riconoscimento viene eseguito utilizzando impostazioni che garantiscono l’individuazione e l’estrazione di tutto il testo possibile dall’immagine di un documento.

​
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 l’utilizzo di ABBYY FineReader Engine 12 in questo scenario. Il metodo proposto utilizza le impostazioni di elaborazione più adatte a questo scenario.
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 relativa password
            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";
    }
}
Le impostazioni più adatte per questo scenario possono essere selezionate in ABBYY FineReader Engine utilizzando il metodo LoadPredefinedProfile dell’oggetto Engine. Questo metodo riceve il nome del profilo come parametro di input. Per ulteriori informazioni, vedere Working with Profiles.ABBYY FineReader Engine supporta 2 varianti di impostazioni per questo scenario:

Nome del profilo

Descrizione

TextExtraction_Accuracy

Le impostazioni sono state ottimizzate per la precisione:

  • Consente di rilevare tutto il testo presente in un’immagine, comprese piccole aree di testo di bassa qualità (immagini e tabelle non vengono rilevate).
  • Non viene eseguita la sintesi completa della struttura logica di un documento.
Il profilo non è destinato alla conversione di un documento in RTF, DOCX o PDF di solo testo. A tale scopo, utilizzare i profili di conversione dei documenti.

TextExtraction_Speed

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

  • Consente di rilevare tutto il testo presente in un’immagine, comprese piccole aree di testo di bassa qualità (immagini e tabelle non vengono rilevate).
  • Non viene eseguita la sintesi completa della struttura logica di un documento.
  • Le operazioni di analisi e riconoscimento del documento risultano più rapide.
Il profilo non è destinato alla conversione di un documento in RTF, DOCX o PDF di solo testo. A tale scopo, utilizzare i profili di conversione dei documenti.

​
C#

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

​
C++ (COM)

// Carica un profilo predefinito
Engine->LoadPredefinedProfile( L"TextExtraction_Accuracy" );
Se si desidera modificare le impostazioni di elaborazione, utilizzare gli appositi oggetti parametro. Per ulteriori informazioni, vedere ottimizzazione aggiuntiva per attività specifiche di seguito.
ABBYY FineReader Engine fornisce l’oggetto FRDocument, che consente di elaborare documenti multipagina.Per caricare e preelaborare 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)

// Apre un file immagine e crea l'oggetto FRDocument
FREngine::IFRDocumentPtr frDocument = Engine->CreateFRDocumentFromImage( L"C:\\MyImage.tif", 0 );
Per riconoscere il documento, è necessario utilizzare i metodi di analisi e riconoscimento dell’oggetto FRDocument. Questo oggetto mette a disposizione un’ampia gamma di metodi per l’analisi e il riconoscimento 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. In alternativa, è anche possibile eseguire in sequenza pre-elaborazione, 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
// Se il profilo è caricato, non è necessario passare parametri aggiuntivi al metodo di elaborazione
frDocument->Process( 0 );
Durante l’analisi, ABBYY FineReader Engine seleziona i blocchi dell’immagine che contengono testo, tabelle, immagini e così via. Durante il riconoscimento, i blocchi che contengono dati testuali vengono popolati con il testo riconosciuto.In ABBYY FineReader Engine, l’oggetto Layout funge da contenitore per i blocchi e il testo riconosciuto. Nello scenario principale di elaborazione dei documenti, il layout viene gestito all’interno dell’oggetto FRDocument, che rappresenta il documento in elaborazione. Per accedere al layout di una pagina del documento, utilizzare la proprietà IFRPage::Layout.Per cercare parole chiave, è possibile visualizzare il testo riconosciuto utilizzando l’oggetto Text, accessibile tramite le proprietà dei blocchi di testo, tabella o Barcode.I dati importanti individuati possono essere salvati o elaborati in base alle esigenze. Per informazioni più dettagliate, vedere ottimizzazione aggiuntiva per attività specifiche di seguito.
In alternativa, è possibile salvare il testo estratto in un formato facilmente ricercabile, come TXT, oppure in un formato strutturato che consenta di recuperare facilmente in seguito le informazioni necessarie, come JSON.Utilizzare il metodo Export dell’oggetto FRDocument con una costante FileExportFormatEnum corrispondente come uno dei parametri. È possibile modificare i parametri di esportazione predefiniti utilizzando il relativo oggetto di esportazione. Per ulteriori informazioni, vedere ottimizzazione aggiuntiva per attività specifiche di seguito.Dopo aver terminato il lavoro con l’oggetto FRDocument, rilasciare tutte le risorse utilizzate da questo oggetto. Utilizzare il metodo IFRDocument::Close.

​
C#

// Salva il testo del documento riconosciuto in formato TXT
frDocument.Export( "C:\\MyText.txt", FREngine.FileExportFormatEnum.FEF_TextUnicodeDefaults, null );
// Rilascia l'oggetto FRDocument
frDocument.Close();

​
C++ (COM)

// Salva il testo del documento riconosciuto in formato TXT
frDocument->Export( L"C:\\MyText.txt", FREngine::FEF_TextUnicodeDefaults, 0 );
// Rilascia l'oggetto FRDocument
frDocument->Close();
Dopo aver terminato di utilizzare ABBYY FineReader Engine, è necessario scaricare l’oggetto Engine. A tale scopo, utilizza la funzione esportata DeinitializeEngine.

​
C#

public class EngineLoader : IDisposable
{
    // Scarica FineReader Engine
    public void Dispose()
    {
        if (engine == null)
        {
            // L'oggetto 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"Error while unloading ABBYY FineReader Engine";
 }
 // Ora è possibile liberare in sicurezza la libreria FREngine.dll
 FreeLibrary( libraryHandle );
 libraryHandle = 0;
}

​
Risorse richieste

Puoi usare il file FREngineDistribution.csv per creare automaticamente un elenco dei file necessari al corretto funzionamento della tua applicazione. Per l’elaborazione con questo scenario, seleziona nella colonna 5 (RequiredByModule) i valori seguenti: Core Core.Resources Opening Opening, Processing Processing Processing.OCR Processing.OCR, Processing.ICR Processing.OCR.NaturalLanguages Processing.OCR.NaturalLanguages, Processing.ICR.NaturalLanguages Se modifichi lo scenario standard, aggiorna di conseguenza i moduli richiesti. Devi inoltre specificare le lingue dell’interfaccia, le lingue di riconoscimento e le eventuali funzionalità aggiuntive utilizzate dalla tua applicazione (ad esempio, Opening.PDF se devi aprire file PDF oppure Processing.OCR.CJK se devi riconoscere testi nelle lingue CJK). Per ulteriori dettagli, vedi Working with the FREngineDistribution.csv File.

​
Ottimizzazione aggiuntiva per attività specifiche

  • Scansione - Solo Windows
    • Scansione
      Descrizione dello scenario ABBYY FineReader Engine per la scansione di documenti.
  • Riconoscimento
  • Riconoscere il testo scritto a mano
    I profili TextExtraction_*** non includono il riconoscimento del testo manoscritto o in stampatello. Se devi riconoscere testo scritto a mano, imposta la proprietà DetectHandwritten dell’oggetto PageAnalysisParams su TRUE.
  • Oggetto PageProcessingParams
    Questo oggetto consente di personalizzare i parametri di analisi e riconoscimento. Utilizzando questo oggetto, puoi 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 - Solo Linux e Windows
    L’elaborazione simultanea può essere utile quando si elabora un numero elevato di immagini. In questo caso, il carico di elaborazione verrà distribuito tra i core del processore durante l’apertura e la pre-elaborazione delle immagini, l’analisi del layout e il riconoscimento, rendendo possibile accelerare l’elaborazione.
    Le modalità di lettura (simultanea o consecutiva) vengono impostate utilizzando la proprietà MultiProcessingMode. La proprietà RecognitionProcessesCount controlla il numero di processi che possono essere avviati.
  • Ricerca di informazioni importanti
    • Lavorare con Layout e blocchi
      Informazioni sul layout della pagina, sui tipi di blocco e su come lavorare con essi.
    • Oggetto Layout
      I parametri di questo oggetto forniscono accesso al layout della pagina e al testo riconosciuto dopo il riconoscimento del documento.
    • Lavorare con il testo
      Lavorare con il testo riconosciuto, i paragrafi, le parole e i simboli.
  • Rilettura del documento mediante parametri speciali per il tipo di dati specificato
  • Salvataggio dei dati

​
Vedi anche

Implementazione degli scenari d’uso di base