> ## Documentation Index > Fetch the complete documentation index at: https://docs.abbyy.com/llms.txt > Use this file to discover all available pages before exploring further. # Reconnaissance de cartes de visite > Capturez les données de cartes de visite avec ABBYY FineReader Engine et exportez-les au format vCard ou dans d'autres formats électroniques — extraction du nom, de l'entreprise, du téléphone, de l'e-mail et du site web. 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. 2. 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. 3. 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](/fr/fine-reader/engine/api-reference/engine-object-iengine-interface). 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](/fr/fine-reader/engine/api-reference/functions/initializeengine-function). Voir aussi [d’autres méthodes pour charger l’objet Engine](/fr/fine-reader/engine/guided-tour/advanced-techniques/programming-aspects/different-ways-to-load-engine) (Win). ### C\# ```csharp theme={null} 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](/fr/fine-reader/engine/api-reference/engine-object-iengine-interface/supplementary-methods/loadpredefinedprofile-method) de l’objet Engine. Cette méthode prend en entrée le nom d’un profil de paramètres. Consultez [Utilisation des profils](/fr/fine-reader/engine/guided-tour/advanced-techniques/working-with-profiles) pour plus d’informations. Les paramètres de ce scénario sont disponibles dans le profil prédéfini [BusinessCardsProcessing](/fr/fine-reader/engine/guided-tour/advanced-techniques/working-with-profiles#businesscardsprocessing) : * Détecte uniquement les cartes de visite (définit la propriété [SynthesizeBusinessCards](/fr/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/synthesisparamsforpage#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\# ```csharp theme={null} // 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 [Optimisation supplémentaire for specific tasks](/fr/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation/business-card-recognition#optimization) ci-dessous pour plus d’informations. Pour charger des images dans FineReader Engine, vous pouvez utiliser les méthodes de ces objets : * [FRDocument](/fr/fine-reader/engine/api-reference/document-related-objects/frdocument) * [BatchProcessor](/fr/fine-reader/engine/api-reference/batch-processor/batchprocessor) pour Linux et Windows 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](/fr/fine-reader/engine/guided-tour/advanced-techniques/parallel-processing). Cette rubrique est consacrée à FRDocument. Pour charger des images dans l’objet FRDocument, effectuez l’une des opérations suivantes : * Lors de la création de l’objet FRDocument, utilisez la méthode [CreateFRDocumentFromImage](/fr/fine-reader/engine/api-reference/engine-object-iengine-interface/creation-methods/createfrdocumentfromimage-method) de l’objet [Engine](/fr/fine-reader/engine/api-reference/engine-object-iengine-interface). * Ajoutez des images depuis un fichier à l’objet FRDocument créé (utilisez la méthode [AddImageFile](/fr/fine-reader/engine/api-reference/document-related-objects/frdocument/addimagefile-method), [AddImageFileWithPassword](/fr/fine-reader/engine/api-reference/document-related-objects/frdocument/addimagefilewithpassword-method) ou [AddImageFileWithPasswordCallback](/fr/fine-reader/engine/api-reference/document-related-objects/frdocument/addimagefilewithpasswordcallback-method)). Toutes ces méthodes utilisent comme paramètre l’objet [PrepareImageMode](/fr/fine-reader/engine/api-reference/image-related-objects/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](/fr/fine-reader/engine/api-reference/engine-object-iengine-interface/creation-methods/createlessobjectgreater-methods), modifiez ensuite ses propriétés selon vos besoins, puis transmettez-le à la fonction qui l’exige. ### C\# ```csharp theme={null} 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](/fr/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/recognizerparams/setpredefinedtextlanguage-method) de l’objet RecognizerParams. Consultez la [liste des langues prédéfinies](/fr/fine-reader/engine/specifications/predefined-languages) 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](/fr/fine-reader/engine/guided-tour/advanced-techniques/tuning-parameters-of-preprocessing-analysis-recognition-and-synthesis). 3. Transmettez les paramètres à l’une des méthodes de traitement (par exemple, la méthode [Process](/fr/fine-reader/engine/api-reference/document-related-objects/frdocument/process-method) de l’objet FRDocument). La méthode remplit les collections de cartes de visite du document et de ses pages ([IFRDocument::BusinessCards](/fr/fine-reader/engine/api-reference/document-related-objects/frdocument#businesscards), [IFRPage::BusinessCards](/fr/fine-reader/engine/api-reference/document-related-objects/frpage#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](/fr/fine-reader/engine/api-reference/document-related-objects/frpage/synthesizebusinesscard-method) ou [SynthesizeBusinessCardEx](/fr/fine-reader/engine/api-reference/document-related-objects/frpage/synthesizebusinesscardex-method) de l’objet FRPage. La méthode renvoie un objet [BusinessCard](/fr/fine-reader/engine/api-reference/document-related-objects/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\# ```csharp theme={null} // 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](/fr/fine-reader/engine/api-reference/document-related-objects/businesscard)) peut contenir les champs suivants :

BusinessCard_pict

Vous pouvez accéder à chaque champ par son type (propriété [FieldByType](/fr/fine-reader/engine/api-reference/document-related-objects/businesscard/fieldbytype-property)) ou par son indice dans la collection de champs (propriété [Field](/fr/fine-reader/engine/api-reference/document-related-objects/businesscard/field-property)). Chaque champ possède la propriété [Value](/fr/fine-reader/engine/api-reference/document-related-objects/businesscardfield#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](/fr/fine-reader/engine/api-reference/document-related-objects/businesscardfield/getcharparams-method)). 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](/fr/fine-reader/engine/api-reference/document-related-objects/businesscardfield/component-property) ou la méthode [FindComponent](/fr/fine-reader/engine/api-reference/document-related-objects/businesscardfield/findcomponent-method). 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](/fr/fine-reader/engine/api-reference/document-related-objects/businesscardfieldcomponent/getcharparams-method)). ### C\# ```csharp theme={null} // 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](/fr/fine-reader/engine/api-reference/document-related-objects/businesscard/exporttovcard-method) 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\# ```csharp theme={null} // 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](/fr/fine-reader/engine/api-reference/engine-object-iengine-interface). Pour ce faire, utilisez la fonction exportée [DeinitializeEngine](/fr/fine-reader/engine/api-reference/functions/deinitializeengine-function). ### C\# ```csharp theme={null} 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](/fr/fine-reader/engine/distribution/distribution-windows/distribution-kit/working-with-the-frenginedistributioncsv-file) 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](/fr/fine-reader/engine/guided-tour/advanced-techniques/recognizing-cjk-languages#cjk)). Consultez [Working with the FREngineDistribution.csv File](/fr/fine-reader/engine/distribution/distribution-windows/distribution-kit/working-with-the-frenginedistributioncsv-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 : * Chargement de l’objet Engine * [Différentes façons de charger l’objet Engine](/fr/fine-reader/engine/guided-tour/advanced-techniques/programming-aspects/different-ways-to-load-engine) pour Windows
Décrit en détail les différentes façons de charger l’objet Engine. * [Utilisation d’ABBYY FineReader Engine dans des applications serveur multithreadées](/fr/fine-reader/engine/guided-tour/advanced-techniques/programming-aspects/using-in-server-applications) pour Windows
Présente les spécificités de l’utilisation de FineReader Engine dans les applications serveur. * [Utilisation des profils](/fr/fine-reader/engine/guided-tour/advanced-techniques/working-with-profiles)
Fournit une description détaillée des profils prédéfinis et des profils utilisateur. * Reconnaissance * [Réglage des paramètres de prétraitement, d’analyse, de reconnaissance et de synthèse](/fr/fine-reader/engine/guided-tour/advanced-techniques/tuning-parameters-of-preprocessing-analysis-recognition-and-synthesis)
Personnalisation du traitement des documents à l’aide d’objets de paramètres de prétraitement, d’analyse, de reconnaissance et de synthèse. * [Traitement parallèle avec ABBYY FineReader Engine](/fr/fine-reader/engine/guided-tour/advanced-techniques/parallel-processing) pour Linux et Windows
Vous pouvez également utiliser une autre méthode de traitement des documents reposant sur Batch Processor. * Exportation * [Réglage des paramètres d’exportation](/fr/fine-reader/engine/guided-tour/advanced-techniques/tuning-export-parameters)
Configuration de l’exportation à l’aide d’objets de paramètres d’exportation. * [Objet XMLExportParams](/fr/fine-reader/engine/api-reference/parameter-objects/export-parameters/xmlexportparams)
Cet objet vous permet de configurer l’enregistrement des résultats de reconnaissance au format XML.
## Voir aussi
[Mise en œuvre des scénarios d’utilisation de base](/fr/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation)