Vai al contenuto principale
In questo scenario, ABBYY FineReader Engine viene utilizzato per leggere i Barcode. I Barcode possono dover essere letti, ad esempio, ai fini della separazione automatica dei documenti, dell’elaborazione dei documenti da parte di un sistema di Document Management o dell’indicizzazione e classificazione dei documenti. Questo scenario può essere utilizzato come parte di altri scenari. Ad esempio, i documenti acquisiti con scanner di produzione ad alta velocità possono essere separati tramite Barcode, oppure i documenti preparati per l’archiviazione a lungo termine possono essere inseriti in sistemi di archiviazione e Document Management in base ai valori dei relativi Barcode. Durante l’estrazione dei Barcode dai testi, il sistema può rilevare tutti i Barcode oppure solo quelli di un determinato tipo con un determinato valore. Il sistema può acquisire il valore di un Barcode e calcolarne il checksum. Per ottenere i risultati migliori e più rapidi dal riconoscimento dei Barcode:
  1. Utilizzare immagini a colori con una risoluzione ottimale di 300 dpi.
  2. Regolare la velocità di riconoscimento utilizzando i profili (per maggiori dettagli, vedere Working with Profiles).
I valori dei Barcode riconosciuti possono essere salvati nei formati più adatti all’ulteriore elaborazione, ad esempio in TXT.

​
Implementazione dello scenario

Gli esempi di codice forniti in questa sezione sono specifici per Windows.
Di seguito viene fornita una descrizione dettagliata del metodo consigliato per utilizzare ABBYY FineReader Engine 12 in questo scenario. Il metodo proposto usa impostazioni di elaborazione considerate le 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 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";
    }
}
Le impostazioni più adatte possono essere selezionate utilizzando il metodo LoadPredefinedProfile dell’oggetto Engine. Questo metodo accetta come parametro di input il nome del profilo di impostazioni da usare. Per ulteriori informazioni sui profili, vedere Working with Profiles.ABBYY FineReader Engine supporta 2 varianti di impostazioni per questo scenario:
Nome del profiloDescrizione
BarcodeRecognition_AccuracyEstrae solo i Barcode (testi, immagini o tabelle non vengono rilevati). Le impostazioni sono state ottimizzate per la precisione. <Warning> Questo profilo richiede il modulo Barcode Autolocation disponibile nella licenza. </Warning>
BarcodeRecognition_SpeedEstrae solo i Barcode (testi, immagini o tabelle non vengono rilevati). Le impostazioni sono state ottimizzate per la velocità di elaborazione. <Warning> Questo profilo richiede il modulo Barcode Autolocation disponibile nella licenza. </Warning>

​
C#

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

​
C++ (COM)

// Carica un profilo predefinito
Engine->LoadPredefinedProfile( L"BarcodeRecognition_Speed" );
Se si desidera modificare le impostazioni usate per l’elaborazione, utilizzare gli oggetti Parameter corrispondenti. Per ulteriori informazioni, vedere la sezione Additional optimization riportata di seguito.
ABBYY FineReader Engine mette a disposizione un oggetto FRDocument per elaborare documenti multipagina. Per caricare e preelaborare le immagini di un 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)

// Apre un file immagine e crea l'oggetto FRDocument
FREngine::IFRDocumentPtr frDocument = Engine->CreateFRDocumentFromImage( L"C:\\MyImage.tif", 0 );
Se è caricato il profilo BarcodeRecognition, puoi usare il metodo Process dell’oggetto FRDocument per estrarre solo i Barcode. In questo caso, ABBYY FineReader Engine rileva solo i blocchi contenenti Barcode. Non vengono rilevati altri blocchi. È possibile accedere ai blocchi di Barcode riconosciuti tramite l’oggetto Layout, che è un sotto-oggetto dell’oggetto FRPage che rappresenta una pagina del documento.Per leggere Barcode di un tipo specifico, specifica i parametri appropriati dell’oggetto BarcodeParams e passa l’oggetto BarcodeParams come parametro a una delle funzioni sopra indicate.

​
C#

// Se il profilo BarcodeRecognition è caricato,
// non è necessario passare parametri aggiuntivi al metodo di elaborazione,
// se i Barcode sono conformi alle specifiche
frDocument.Process( null );
// Se devi leggere Barcode di un tipo specifico
// Crea un oggetto DocumentProcessingParams
FREngine.IDocumentProcessingParams dpp = engine.CreateDocumentProcessingParams();
// Specifica i parametri necessari
dpp.PageProcessingParams.PageAnalysisParams.BarcodeParams.Type = ( int )FREngine.BarcodeTypeEnum.BT_Code39;
// Ora riconosci i Barcode con questi parametri
frDocument.Process( dpp );

​
C++ (COM)

// Se il profilo BarcodeRecognition è caricato,
// non è necessario passare parametri aggiuntivi al metodo di elaborazione,
// se i Barcode sono conformi alle specifiche
frDocument->Process( 0 );
// Se devi leggere Barcode di un tipo specifico
// Crea un oggetto DocumentProcessingParams
FREngine::IDocumentProcessingParamsPtr params = Engine->CreateDocumentProcessingParams();
// Specifica i parametri necessari
params->PageProcessingParams->PageAnalysisParams->BarcodeParams->Type = FREngine::BT_Code39;
// Ora riconosci i Barcode con questi parametri
frDocument->Process( params );
Per salvare i valori dei Barcode riconosciuti in un file, puoi usare il metodo Export dell’oggetto FRDocument, specificando la costante FileExportFormatEnum come uno dei parametri. Ad esempio, in questo scenario è possibile esportare in formato TXT. Puoi modificare i parametri di esportazione predefiniti usando il corrispondente oggetto di esportazione. Per ulteriori informazioni, vedi Ulteriore ottimizzazione per attività specifiche qui sotto.Dopo aver terminato di lavorare con l’oggetto FRDocument, rilascia tutte le risorse usate da questo oggetto. Usa il metodo IFRDocument::Close.

​
C#

// Salva i Barcode riconosciuti in un formato qualsiasi (ad esempio TXT)
frDocument.Export( "C:\\barcodes.txt", FREngine.FileExportFormatEnum.FEF_TextUnicodeDefaults, null );
// Rilascia l'oggetto FRDocument
frDocument.Close();

​
C++ (COM)

// Salva i Barcode riconosciuti in un formato qualsiasi (ad esempio TXT)
frDocument->Export( L"C:\\barcodes.txt", FREngine::FEF_TextUnicodeDefaults, 0 );
// 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

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 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

Queste sono le sezioni del file della Guida in cui puoi trovare ulteriori informazioni sulla configurazione dei parametri per le varie fasi di elaborazione:
  • Estrazione e lettura dei Barcode
    • Oggetto BarcodeParams
      Questo oggetto consente di configurare i parametri di analisi e lettura dei Barcode.
    • Riconoscimento dei Barcode
      Descrive i casi particolari del riconoscimento dei Barcode e fornisce suggerimenti per lavorare con i Barcode.
    • Tipi di Barcode
      L’elenco dei Barcode supportati in ABBYY FineReader Engine 12 e le relative brevi descrizioni.
    • Oggetto FRDocument
      Oltre ai valori dei Barcode, potrebbe essere necessario estrarre altre informazioni contenute nel documento. In questo caso, puoi usare i metodi dell’oggetto FRDocument.
    • Oggetto PageProcessingParams
      Questo oggetto consente di configurare i parametri di analisi e riconoscimento per l’intero documento. Usandolo, puoi specificare se riconoscere i valori dei Barcode. I parametri di lettura dei Barcode sono accessibili tramite le proprietà BarcodeParams e DetectBarcodes del sotto-oggetto PageAnalysisParams.
    • Lavorare con Layout e Blocks
      Puoi anche contrassegnare manualmente i blocchi Barcode e specificarne i parametri di analisi e lettura. Questa sezione fornisce informazioni dettagliate sull’uso dei blocchi.
  • Lavorare con i valori dei Barcode riconosciuti
    • Oggetto BarcodeBlock
      Le proprietà Text e BarcodeText di questo oggetto contengono il valore del Barcode ottenuto dal riconoscimento. Le altre proprietà di questo oggetto possono essere usate per ottenere il tipo di Barcode, il suo orientamento e altri parametri.
  • Esportazione

​
Vedi anche

Implementazione degli scenari d’uso di base