Vai al contenuto principale
I biglietti da visita contengono informazioni professionali su un’azienda o una persona. Possono includere il nome di una persona, l’azienda, numeri di telefono, fax, e-mail, indirizzi di siti web e altre informazioni simili. Potrebbe essere necessario acquisire queste informazioni da biglietti da visita cartacei e salvarle in formato elettronico. Può trattarsi, ad esempio, della rubrica elettronica di un telefono cellulare, di un client di posta elettronica o di qualsiasi altro sistema di archiviazione dei dati. Ad esempio, i biglietti da visita vengono spesso inviati via e-mail o tramite rete nel formato vCard. I passaggi principali da eseguire in questo scenario sono:
  1. Ottenere una copia digitale di un biglietto da visita
È possibile eseguire la scansione oppure scattare una foto di un biglietto da visita. Le foto scattate con le fotocamere digitali dei dispositivi mobili possono avere una risoluzione e una qualità basse. Pertanto, potrebbe essere necessaria un’ulteriore preparazione delle immagini.
  1. Riconoscere i biglietti da visita
Le pagine acquisite tramite scansione possono contenere più biglietti da visita per pagina. Il riconoscimento deve essere di alta qualità; tutte le informazioni devono essere estratte con precisione.
  1. Salvare i dati riconosciuti in un formato adatto
È possibile salvare i dati riconosciuti in diversi sistemi di archiviazione dei dati oppure esportarli nel formato vCard e inviarli tramite e-mail.

​
Implementazione dello scenario

Gli esempi di codice forniti in questo argomento sono specifici per Windows.
Di seguito viene fornita una descrizione dettagliata del metodo consigliato per usare ABBYY FineReader Engine in questo scenario.
Per iniziare a utilizzare ABBYY FineReader Engine, è necessario creare l’oggetto Engine. L’oggetto Engine si trova al vertice della gerarchia degli oggetti di ABBYY FineReader Engine e fornisce varie impostazioni globali, alcuni metodi di elaborazione e i metodi per creare gli altri oggetti.Per creare l’oggetto Engine, puoi usare la funzione InitializeEngine. Vedi anche altri modi per caricare l’oggetto Engine (Win).

​
C#

public class EngineLoader : IDisposable
{
    public EngineLoader()
    {
        // Inizializza queste variabili con il percorso completo di FREngine.dll, il tuo 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 = "";
        // Carica la libreria FREngine.dll
        dllHandle = LoadLibraryEx(enginePath, IntPtr.Zero, LOAD_WITH_ALTERED_SEARCH_PATH);
           
        try
        {
            if (dllHandle == IntPtr.Zero)
            {
                throw new Exception("Can't load " + enginePath);
            }
            IntPtr initializeEnginePtr = GetProcAddress(dllHandle, "InitializeEngine");
            if (initializeEnginePtr == IntPtr.Zero)
            {
                throw new Exception("Can't find InitializeEngine function");
            }
            IntPtr deinitializeEnginePtr = GetProcAddress(dllHandle, "DeinitializeEngine");
            if (deinitializeEnginePtr == IntPtr.Zero)
            {
                throw new Exception("Can't find DeinitializeEngine function");
            }
            IntPtr dllCanUnloadNowPtr = GetProcAddress(dllHandle, "DllCanUnloadNow");
            if (dllCanUnloadNowPtr == IntPtr.Zero)
            {
                throw new Exception("Can't find DllCanUnloadNow function");
            }
            // Converte 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));
            // Chiama 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)
        {
            // Libera la libreria FREngine.dll
            engine = null;
            // Elimina 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;
}
Puoi caricare le impostazioni di elaborazione adatte a questo scenario utilizzando il metodo LoadPredefinedProfile dell’oggetto Engine. Questo metodo accetta come parametro di input il nome di un profilo di impostazioni. Per ulteriori informazioni, consulta Uso dei profili.Le impostazioni per questo scenario sono disponibili nel profilo predefinito BusinessCardsProcessing:
  • Rileva solo i biglietti da visita (imposta la proprietà SynthesizeBusinessCards dell’oggetto SynthesisParamsForPage su TRUE).
  • Abilita il rilevamento di tutto il testo nell’immagine, incluse piccole aree di testo di bassa qualità (immagini e tabelle non vengono rilevate).
  • Esegue la correzione della risoluzione.
  • Non esegue la sintesi completa della struttura logica di un documento.

​
C#

// Carica il profilo predefinito
engine.LoadPredefinedProfile("BusinessCardsProcessing");
Se desideri modificare le impostazioni di elaborazione, usa gli oggetti Parameter appropriati. Per ulteriori informazioni, consulta la sezione Additional optimization for specific tasks riportata di seguito.
Per caricare immagini in FineReader Engine, puoi usare i metodi dei seguenti oggetti:
Gli utenti Linux e Windows possono consultare Parallel Processing with ABBYY FineReader Engine per conoscere vantaggi e svantaggi di ciascun approccio. Questo argomento si concentra su FRDocument.
Per caricare immagini nell’oggetto FRDocument, esegui una delle operazioni seguenti:Tutti questi metodi usano come parametro l’oggetto PrepareImageMode, che consente di specificare diversi parametri di preelaborazione delle immagini. Crea questo oggetto chiamando la funzione IEngine::CreatePrepareImageMode, quindi modificane le proprietà secondo necessità e passalo infine alla funzione che lo richiede.

​
C#

FREngine.IEngine engine;
string imagePath;
FREngine.IPrepareImageMode pim = engine.CreatePrepareImageMode();
pim.DocumentType = FREngine.DocumentTypeEnum.DT_BusinessCard;
FREngine.IFRDocument frDoc = engine.CreateFRDocument();
frDoc.AddImageFile(imagePath, pim, null);
Per riconoscere i biglietti da visita:
  1. Specificare la lingua dei biglietti da visita utilizzando il metodo SetPredefinedTextLanguage dell’oggetto RecognizerParams. Vedere l’elenco delle lingue predefinite disponibili per il riconoscimento dei biglietti da visita.
  2. Impostare altri parametri di elaborazione, se necessario. Vedere Ottimizzazione dei parametri di pre-elaborazione, analisi, riconoscimento e sintesi della pagina.
  3. Passare i parametri a uno qualsiasi dei metodi di elaborazione (ad esempio, il metodo Process dell’oggetto FRDocument). Il metodo compila le raccolte dei biglietti da visita del documento e delle relative pagine (IFRDocument::BusinessCards, IFRPage::BusinessCards).
È anche possibile sintetizzare un biglietto da visita a partire dall’intera pagina o da una regione di ciascuna pagina utilizzando il metodo SynthesizeBusinessCard o SynthesizeBusinessCardEx dell’oggetto FRPage. Il metodo restituisce un oggetto BusinessCard. Si noti che, in questo caso, il biglietto da visita non viene aggiunto alla raccolta dei biglietti da visita della pagina. Questo approccio è particolarmente utile se si sceglie una modalità di elaborazione che utilizza Batch Processor.

​
C#

// Crea i parametri di elaborazione del documento
FREngine.IDocumentProcessingParams dpp = engine.CreateDocumentProcessingParams();
// Esegue il riconoscimento con i parametri specificati
frDoc.Process( dpp );
// Accede a un biglietto da visita
FREngine.IBusinessCard card = frDoc.BusinessCards[0];
Un biglietto da visita riconosciuto (l’oggetto BusinessCard) può contenere i seguenti field:

BusinessCard_pict

  • Nome della persona
  • Nome dell’azienda
  • Ruolo in azienda
  • Indirizzo dell’azienda
  • Numero di telefono
  • Fax
  • Numero di cellulare
  • E-mail
  • Sito web
Puoi accedere a ciascun field in base al suo tipo (proprietà FieldByType) oppure in base al suo indice nella raccolta di fields (proprietà Field). Ogni field ha la proprietà Value, che consente di accedere al valore del field in formato string. Per ogni carattere del field sono disponibili le relative varianti di riconoscimento (metodo GetCharParams).Alcuni field possono essere costituiti da più componenti; ad esempio, il field dell’indirizzo può contenere CAP, paese, stato degli USA, città e indirizzo. Per accedere a un componente del field, puoi usare la proprietà Component o il metodo FindComponent. La prima consente di accedere al componente in base al suo indice; il secondo individua il componente in base al suo tipo. Per ogni componente, puoi visualizzarne il tipo e il valore e ottenere i parametri e le varianti di riconoscimento per ogni carattere (metodo GetCharParams).

​
C#

// Ottiene il field del nome
FREngine.IBusinessCardField nameField = card.FieldByType( FREngine.BusinessCardFieldTypeEnum.BCFT_Name, 0 );
// Ottiene il componente che contiene il nome
FREngine.IBusinessCardFieldComponent firstNameComponent =
  nameField.FindComponent( FREngine.BusinessCardFieldComponentTypeEnum.BCFCT_FirstName );
// Il nome riconosciuto
string firstName = firstNameComponent.Value;
L’oggetto BusinessCard mette a disposizione il metodo speciale ExportToVCard per salvare un biglietto da visita in formato vCard. Il percorso del file viene passato come parametro.Puoi salvare il biglietto da visita in qualsiasi altro formato di esportazione disponibile, ad esempio in XML.

​
C#

// Salva i dati riconosciuti in formato vCard
card.ExportToVCard("D:\\sample.vcf");
// Salva in XML
frDoc.Export("D:\\Demo.xml", FREngine.FileExportFormatEnum.FEF_XML, null);
Dopo aver terminato di utilizzare ABBYY FineReader Engine, è necessario rilasciare l’oggetto Engine. Per farlo, utilizzare la funzione esportata DeinitializeEngine.

​
C#

public class EngineLoader : IDisposable
{
    // Rilascia 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 un'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;
}

​
Risorse richieste

Puoi utilizzare 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.BCR 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 inoltre specificare le lingue dell’interfaccia, le lingue di riconoscimento e tutte le funzionalità aggiuntive utilizzate 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.

​
Ulteriori ottimizzazioni

Queste sono le sezioni del file della Guida in cui puoi trovare ulteriori informazioni sulla configurazione dei parametri per le varie fasi di elaborazione:

​
Vedi anche

Implementazione degli scenari di utilizzo di base