Vai al contenuto principale
Il risultato di questo scenario è una versione modificabile di un documento. In questo scenario, le immagini dei documenti vengono riconosciute mantenendo intatta tutta la formattazione originale e i dati vengono salvati in un formato di file modificabile. Di conseguenza, si ottengono versioni modificabili dei documenti, che possono essere facilmente controllate per correggere eventuali errori e modificate. Sarà inoltre possibile copiare tutto o parte del testo per riutilizzarlo. Un documento passa attraverso diverse fasi di elaborazione, che per alcuni aspetti differiscono leggermente dagli altri scenari comuni:
  1. Pre-elaborazione di immagini o foto acquisite tramite scansione
Le immagini ottenute tramite uno scanner o una fotocamera digitale possono richiedere alcuni ritocchi prima di poter essere sottoposte al riconoscimento ottico. Ad esempio, le immagini con rumore o con linee di testo distorte richiederanno alcune correzioni affinché il riconoscimento ottico abbia esito positivo.
  1. Riconoscimento con ripristino completo della struttura e della formattazione del documento
Durante il riconoscimento di un documento, vengono identificati vari elementi del layout (testo, tabelle, immagini, Separator, ecc.) del documento. Nel corso della sintesi del documento, viene ripristinata la struttura logica del documento, mentre la sintesi della pagina consente di ripristinare completamente la formattazione del documento (font, stili, ecc.).
  1. Esportazione in un formato modificabile
Il documento riconosciuto viene salvato in un formato modificabile, come RTF o DOCX.

​
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 convertire i documenti. Il metodo proposto utilizza 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 superiore nella gerarchia degli oggetti di ABBYY FineReader Engine e fornisce varie impostazioni globali, alcuni metodi di elaborazione e metodi per creare gli 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");
            }
            // 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 per 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, tramite il metodo LoadPredefinedProfile dell’oggetto Engine, tutte le impostazioni più adatte a questo scenario. Questo metodo riceve il nome del profilo come parametro di input. Per ulteriori informazioni, vedere Uso dei profili.ABBYY FineReader Engine supporta 2 set di impostazioni per questo scenario:

Nome del profilo

Descrizione

DocumentConversion_Accuracy

Le impostazioni sono state ottimizzate per la precisione:

  • Qualità ottimale. Abilita il rilevamento dello stile dei caratteri e la sintesi completa della struttura logica del documento.

DocumentConversion_Normal

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

  • Qualità ottimale. Abilita il rilevamento dello stile dei caratteri e la sintesi completa della struttura logica del documento.
  • L’orientamento dell’immagine non viene corretto.
  • Il processo di analisi del documento è accelerato.

​
C#

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

​
C++ (COM)

// Carica un profilo predefinito
Engine->LoadPredefinedProfile( L"DocumentConversion_Normal" );
Se si desidera modificare le impostazioni di elaborazione, utilizzare gli oggetti parametro appropriati. Per ulteriori informazioni, vedere Ottimizzazione aggiuntiva per attività specifiche di seguito.
ABBYY FineReader Engine mette a disposizione l’oggetto FRDocument, che consente di elaborare documenti multipagina. L’uso di questo oggetto consente di preservare l’organizzazione logica del documento, mantenendo il testo originale, le colonne, 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 eseguire una delle seguenti operazioni:

​
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 );
La pre-elaborazione delle immagini con il profilo DocumentConversion_Normal caricato non include il rilevamento dell’orientamento. Se si desidera che l’orientamento dell’immagine venga rilevato automaticamente, sarà necessario configurare parametri aggiuntivi e passare l’oggetto corrispondente alla funzione di pre-elaborazione. Per ulteriori informazioni, vedere Ottimizzazione aggiuntiva per attività specifiche di seguito.
Per riconoscere un documento, consigliamo di utilizzare i metodi di analisi e riconoscimento dell’oggetto FRDocument. Questo oggetto fornisce un’intera 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 in un’unica operazione, è Process. Inoltre, sfrutta nel modo più efficiente le funzionalità di elaborazione simultanea dei sistemi multiprocessore e multicore. Tuttavia, puoi anche eseguire in sequenza la pre-elaborazione, l’analisi, il riconoscimento e la 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, puoi utilizzare il metodo Export dell’oggetto FRDocument, specificando la costante FileExportFormatEnum come uno dei parametri. Puoi modificare i parametri predefiniti di esportazione usando l’oggetto di esportazione corrispondente. Per ulteriori informazioni, consulta Ottimizzazione aggiuntiva per attività specifiche più avanti.Dopo aver terminato il lavoro con l’oggetto FRDocument, rilascia tutte le risorse utilizzate da questo oggetto. Usa il metodo IFRDocument::Close.

​
C#

// Salva il documento riconosciuto in un formato modificabile (ad esempio, RTF)
frDocument.Export( "C:\\MyText.rtf", FREngine.FileExportFormatEnum.FEF_RTF, null );
// Rilascia l'oggetto FRDocument
frDocument.Close();

​
C++ (COM)

// Salva il documento riconosciuto in un formato modificabile (ad esempio, RTF)
frDocument->Export( L"C:\\MyText.rtf", FREngine::FEF_RTF, 0 );
// Rilascia l'oggetto FRDocument
frDocument->Close();
Dopo aver finito di lavorare 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;
        // 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";
 }
 // A questo punto è 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 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, adegua di conseguenza i moduli richiesti. Devi anche specificare le lingue dell’interfaccia, le lingue di riconoscimento e tutte le funzionalità aggiuntive usate dalla tua applicazione (come, ad esempio, Opening.PDF se devi aprire file PDF, oppure Processing.OCR.CJK se devi riconoscere testi nelle 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 di documenti.
  • Riconoscimento
    • Ottimizzazione dei parametri di pre-elaborazione, analisi, riconoscimento e sintesi
      Personalizzazione dell’elaborazione dei documenti mediante oggetti dei parametri di analisi, riconoscimento e sintesi.
    • Riconoscere il testo scritto a mano
      I profili DocumentConversion_*** non includono il riconoscimento del testo scritto a mano o in stampatello. Se è necessario riconoscere il testo scritto a mano, impostare la proprietà DetectHandwritten dell’oggetto PageAnalysisParams su TRUE.
    • Oggetto PageProcessingParams
      Questo oggetto consente di personalizzare i parametri di analisi e riconoscimento. Con questo oggetto, è possibile specificare 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 della sua formattazione.
    • Oggetto MultiProcessingParams - Implementato per 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, il riconoscimento e l’esportazione, rendendo possibile accelerare 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 d’uso di base