Passer au contenu principal
Les cartes de visite contiennent des informations professionnelles sur une entreprise ou une personne. Elles peuvent inclure le nom d’une personne, le nom de l’entreprise, des numéros de téléphone, un numéro de fax, une adresse e-mail, des adresses de sites web et d’autres informations similaires. Il peut être nécessaire de récupérer ces informations à partir de cartes de visite papier et de les enregistrer sous forme électronique. Il peut s’agir d’un carnet d’adresses électronique sur un téléphone mobile, d’un client de messagerie ou de tout autre système de stockage de données. Par exemple, les cartes de visite sont souvent transmises par e-mail ou via un réseau au format vCard. Les principales étapes à suivre dans ce scénario :
  1. Obtention d’une copie numérique d’une carte de visite
Vous numérisez une carte de visite ou en prenez une photo. Les photos prises avec l’appareil photo d’un appareil mobile peuvent avoir une faible résolution et une qualité médiocre. Une préparation supplémentaire des images peut donc être nécessaire.
  1. Reconnaissance des cartes de visite
Les pages numérisées peuvent contenir plusieurs cartes de visite sur une même page. La reconnaissance doit être de haute qualité ; toutes les informations doivent être extraites avec précision.
  1. Enregistrement des données reconnues dans un format approprié
Vous pouvez enregistrer les données reconnues dans différents systèmes de stockage de données, ou les exporter au format vCard et les envoyer par e-mail.

​
Mise en œuvre du scénario

Les exemples de code fournis dans cette rubrique sont spécifiques à Windows.
Vous trouverez ci-dessous une description détaillée de la méthode recommandée pour utiliser ABBYY FineReader Engine dans ce scénario.
Pour commencer à utiliser ABBYY FineReader Engine, vous devez créer l’objet Engine. L’objet Engine se trouve au sommet de la hiérarchie des objets d’ABBYY FineReader Engine et fournit divers paramètres globaux, certaines méthodes de traitement, ainsi que des méthodes permettant de créer les autres objets.Pour créer l’objet Engine, vous pouvez utiliser la fonction InitializeEngine. Voir aussi d’autres méthodes pour charger l’objet Engine (Win).

​
C#

public class EngineLoader : IDisposable
{
    public EngineLoader()
    {
        // Initialisez ces variables avec le chemin complet vers FREngine.dll, votre Customer Project ID,
        // et, le cas échéant, le chemin vers votre fichier de jeton de licence en ligne et le mot de passe de la licence en ligne
        string enginePath = "";
        string customerProjectId = "";
        string licensePath = "";
        string licensePassword = "";
        // Charger la bibliothèque 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");
            }
            // Convertir les pointeurs en délégués
            initializeEngine = (InitializeEngine)Marshal.GetDelegateForFunctionPointer(
                initializeEnginePtr, typeof(InitializeEngine));
            deinitializeEngine = (DeinitializeEngine)Marshal.GetDelegateForFunctionPointer(
                deinitializeEnginePtr, typeof(DeinitializeEngine));
            dllCanUnloadNow = (DllCanUnloadNow)Marshal.GetDelegateForFunctionPointer(
                dllCanUnloadNowPtr, typeof(DllCanUnloadNow));
            // Appeler la fonction InitializeEngine 
            // en lui transmettant le chemin vers le fichier de licence en ligne et le mot de passe de la licence en ligne
            int hresult = initializeEngine(customerProjectId, licensePath, licensePassword, 
                "", "", false, ref engine);
            Marshal.ThrowExceptionForHR(hresult);
        }
        catch (Exception)
        {
            // Libérer la bibliothèque FREngine.dll
            engine = null;
            // Supprimer tous les objets avant l’appel à FreeLibrary
            GC.Collect();
            GC.WaitForPendingFinalizers();
            GC.Collect();
            FreeLibrary(dllHandle);
            dllHandle = IntPtr.Zero;
            initializeEngine = null;
            deinitializeEngine = null;
            dllCanUnloadNow = null;
            throw;
        }
    }
    // Fonctions de 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);
    // Fonctions de 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();
    // variables privées
    private FREngine.IEngine engine = null;
    // Handle de FREngine.dll
    private IntPtr dllHandle = IntPtr.Zero;
    private InitializeEngine initializeEngine = null;
    private DeinitializeEngine deinitializeEngine = null;
    private DllCanUnloadNow dllCanUnloadNow = null;
}
Vous pouvez charger les paramètres de traitement adaptés à ce scénario à l’aide de la méthode LoadPredefinedProfile de l’objet Engine. Cette méthode prend en entrée le nom d’un profil de paramètres. Consultez Utilisation des profils pour plus d’informations.Les paramètres de ce scénario sont disponibles dans le profil prédéfini BusinessCardsProcessing :
  • Détecte uniquement les cartes de visite (définit la propriété SynthesizeBusinessCards de l’objet SynthesisParamsForPage sur TRUE).
  • Active la détection de tout le texte de l’image, y compris les petites zones de texte de mauvaise qualité (les images et les tableaux ne sont pas détectés).
  • Effectue une correction de la résolution.
  • N’effectue pas de synthèse complète de la structure logique d’un document.

​
C#

// Charger le profil prédéfini
engine.LoadPredefinedProfile("BusinessCardsProcessing");
Si vous souhaitez modifier les paramètres de traitement, utilisez les objets Parameter appropriés. Consultez Additional optimization for specific tasks ci-dessous pour plus d’informations.
Pour charger des images dans FineReader Engine, vous pouvez utiliser les méthodes de ces objets :
Les utilisateurs de Linux et de Windows peuvent consulter les avantages et les inconvénients de chaque approche dans Traitement parallèle avec ABBYY FineReader Engine. Cette rubrique est consacrée à FRDocument.
Pour charger des images dans l’objet FRDocument, effectuez l’une des opérations suivantes :Toutes ces méthodes utilisent comme paramètre l’objet PrepareImageMode, qui vous permet de spécifier différents paramètres de prétraitement de l’image. Créez cet objet en appelant la fonction IEngine::CreatePrepareImageMode, modifiez ensuite ses propriétés selon vos besoins, puis transmettez-le à la fonction qui l’exige.

​
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);
Pour reconnaître des cartes de visite :
  1. Spécifiez la langue des cartes de visite à l’aide de la méthode SetPredefinedTextLanguage de l’objet RecognizerParams. Consultez la liste des langues prédéfinies prises en charge pour la reconnaissance des cartes de visite.
  2. Définissez d’autres paramètres de traitement si nécessaire. Consultez Réglage des paramètres de prétraitement, d’analyse, de reconnaissance et de synthèse.
  3. Transmettez les paramètres à l’une des méthodes de traitement (par exemple, la méthode Process de l’objet FRDocument). La méthode remplit les collections de cartes de visite du document et de ses pages (IFRDocument::BusinessCards, IFRPage::BusinessCards).
Vous pouvez également synthétiser une carte de visite à partir de la page entière ou d’une région de chaque page à l’aide de la méthode SynthesizeBusinessCard ou SynthesizeBusinessCardEx de l’objet FRPage. La méthode renvoie un objet BusinessCard. Notez que, dans ce cas, la carte de visite n’est pas ajoutée à la collection de cartes de visite de la page. Cette approche est particulièrement utile si vous choisissez le mode de traitement qui utilise Batch Processor.

​
C#

// Créer les paramètres du traitement du document
FREngine.IDocumentProcessingParams dpp = engine.CreateDocumentProcessingParams();
// Effectuer la reconnaissance avec les paramètres spécifiés
frDoc.Process( dpp );
// Accéder à une carte de visite
FREngine.IBusinessCard card = frDoc.BusinessCards[0];
Une carte de visite reconnue (l’objet BusinessCard) peut contenir les champs suivants :

BusinessCard_pict

  • Nom de la personne
  • Nom de l’entreprise
  • Fonction dans l’entreprise
  • Adresse de l’entreprise
  • Numéro de téléphone
  • Fax
  • Numéro de téléphone portable
  • E-mail
  • Site web
Vous pouvez accéder à chaque champ par son type (propriété FieldByType) ou par son indice dans la collection de champs (propriété Field). Chaque champ possède la propriété Value, qui donne accès à la valeur du champ au format string. Pour chaque caractère du champ, les variantes de reconnaissance correspondantes sont disponibles (méthode GetCharParams).Certains champs peuvent être composés de plusieurs composants. Par exemple, le champ d’adresse peut contenir le code postal, le pays, l’État des USA, la ville et l’adresse postale. Pour accéder à un composant de champ, vous pouvez utiliser la propriété Component ou la méthode FindComponent. La première permet d’accéder au composant par son indice ; la seconde permet de trouver le composant par son type. Pour chaque composant, vous pouvez consulter son type et sa valeur, et obtenir les paramètres et les variantes de reconnaissance de chaque caractère (méthode GetCharParams).

​
C#

// Obtenir le champ du nom
FREngine.IBusinessCardField nameField = card.FieldByType( FREngine.BusinessCardFieldTypeEnum.BCFT_Name, 0 );
// Obtenir le composant qui contient le prénom
FREngine.IBusinessCardFieldComponent firstNameComponent =
  nameField.FindComponent( FREngine.BusinessCardFieldComponentTypeEnum.BCFCT_FirstName );
// Le prénom reconnu
string firstName = firstNameComponent.Value;
L’objet BusinessCard fournit la méthode spéciale ExportToVCard pour enregistrer une carte de visite au format vCard. Le chemin du fichier est passé en paramètre.Vous pouvez enregistrer la carte de visite dans tout autre format d’exportation disponible, par exemple en XML.

​
C#

// Enregistrer les données reconnues au format vCard
card.ExportToVCard("D:\\sample.vcf");
// Enregistrer en XML
frDoc.Export("D:\\Demo.xml", FREngine.FileExportFormatEnum.FEF_XML, null);
Une fois que vous avez fini d’utiliser ABBYY FineReader Engine, vous devez décharger l’objet Engine. Pour ce faire, utilisez la fonction exportée DeinitializeEngine.

​
C#

public class EngineLoader : IDisposable
{
    // Décharger FineReader Engine
    public void Dispose()
    {
        if (engine == null)
        {
            // Engine n’a pas été chargé
            return;
        }
        engine = null;
        // Suppression de tous les objets avant l’appel à 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;
        // lever une exception après le nettoyage
        Marshal.ThrowExceptionForHR(hresult);
    }
    // Fonctions de 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);
    // Fonctions de 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();
    // Variables privées
    private FREngine.IEngine engine = null;
    // Handle de FREngine.dll
    private IntPtr dllHandle = IntPtr.Zero;
    private InitializeEngine initializeEngine = null;
    private DeinitializeEngine deinitializeEngine = null;
    private DllCanUnloadNow dllCanUnloadNow = null;
}

​
Ressources requises

Vous pouvez utiliser le fichier FREngineDistribution.csv pour créer automatiquement une liste des fichiers nécessaires au fonctionnement de votre application. Pour le traitement dans ce scénario, sélectionnez dans la colonne 5 (RequiredByModule) les valeurs suivantes : 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 Si vous modifiez le scénario standard, adaptez les modules requis en conséquence. Vous devez également spécifier les langues de l’interface, les langues de reconnaissance et toutes les fonctionnalités supplémentaires utilisées par votre application (par exemple, Opening.PDF si vous devez ouvrir des fichiers PDF, ou Processing.OCR.CJK si vous devez reconnaître des textes en langues CJK). Consultez Working with the FREngineDistribution.csv File pour plus de détails.

​
Optimisation supplémentaire

Voici les sections du fichier d’aide dans lesquelles vous trouverez des informations complémentaires sur la configuration des paramètres pour les différentes étapes de traitement :

​
Voir aussi

Mise en œuvre des scénarios d’utilisation de base