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

# Capture de la zone lisible par machine

> Capturez la zone lisible par machine (MRZ) sur les passeports et les documents d’identité avec ABBYY FineReader Engine — extrayez des données champ par champ conformes au document 9303 de l’ICAO.

Les documents de voyage officiels ou les documents d’identité de nombreux pays contiennent une zone lisible par machine (MRZ), qui assure un traitement plus précis des données du document. La MRZ comprend 2 ou 3 lignes de texte en police OCR-B rédigées conformément au document 9303 de l’[ICAO](http://en.wikipedia.org/wiki/International_Civil_Aviation_Organization) (voir les spécifications sur le [site web](http://www.icao.int/publications/pages/publication.aspx?docnum=9303) de l’ICAO).

Ce scénario sert à extraire les données d’une zone lisible par machine sur des documents d’identité lors des processus d’intégration ou de vérification des clients. Le système reconnaît la MRZ sur l’image du document et en extrait les données. Les données extraites contiennent plusieurs champs avec des informations personnelles relatives au document et à son titulaire (type de document et date d’expiration, prénom et nom du titulaire, etc.). Vous pouvez parcourir les champs, vérifier les données et les enregistrer dans un fichier externe pour un traitement ultérieur.

Pour extraire les données de la MRZ, les fichiers image obtenus par numérisation ou enregistrés au format électronique passent généralement par plusieurs étapes de traitement, chacune ayant ses propres particularités :

1. Prétraitement des images numérisées ou des photos

   Vous numérisez ou photographiez la page d’identité d’un document d’identité comportant une MRZ. Les photos prises avec l’appareil photo d’un appareil mobile peuvent avoir une faible résolution et une qualité médiocre. En outre, les images peuvent nécessiter un prétraitement avant la reconnaissance.

2. Extraction des données de la MRZ

   Une seule MRZ au maximum peut être capturée par image. Le texte de chacune des 2 ou 3 lignes sera reconnu et analysé afin d’extraire les champs de données. Certains champs, ainsi que la MRZ dans son ensemble, comportent des sommes de contrôle, ce qui vous aidera à vérifier les données.

3. Exportation vers un fichier externe

   Vous pouvez également enregistrer les données extraites dans un format externe : XML et JSON sont pris en charge.

La procédure décrite ci-dessous est implémentée dans l’exemple de code [MRZExtraction](/fr/fine-reader/engine/guided-tour/samples#mrzextraction) pour Linux et Windows.

<div id="scenario-implementation">
  ## Mise en œuvre du scénario
</div>

<Note>
  Les exemples de code fournis dans cette rubrique sont spécifiques à Windows.
</Note>

Vous trouverez ci-dessous une description détaillée de la méthode recommandée pour utiliser ABBYY FineReader Engine 12 dans ce scénario. Cette méthode s’appuie sur les paramètres de traitement les mieux adaptés à ce scénario.

<Accordion title="Étape 1. Chargement d’ABBYY FineReader Engine">
  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 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 également [d’autres façons de 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 Online License ainsi que le mot de passe Online License
          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 passant le chemin du fichier Online License et le mot de passe Online License
              int hresult = initializeEngine(customerProjectId, licensePath, licensePassword, 
                  "", "", false, ref engine);
              Marshal.ThrowExceptionForHR(hresult);
          }
          catch (Exception)
          {
              // Libérer la bibliothèque FREngine.dll
              engine = null;
              // Suppression de 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;
  }
  ```
</Accordion>

<Accordion title="Étape 2. Chargement des paramètres du scénario">
  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 utilise comme paramètre d’entrée le nom d’un profil de paramètres. Veuillez consulter [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 [MachineReadableZone](/fr/fine-reader/engine/guided-tour/advanced-techniques/working-with-profiles#machinereadablezone) :

  * Active la détection et l’extraction de l’ensemble du texte d’une image (les illustrations, les graphiques vectoriels et les tableaux ne sont pas détectés).
  * La correction de la résolution et de la géométrie est effectuée automatiquement.

  ### C\#

  ```csharp theme={null}
  // Charger le profil prédéfini
  engine.LoadPredefinedProfile("MachineReadableZone");
  ```

  Si vous souhaitez modifier les paramètres de traitement, utilisez les objets Parameter appropriés. Veuillez consulter [Optimisation supplémentaire pour des tâches spécifiques](/fr/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation/machine-readable-zone-capture#optimization) ci-dessous pour plus d’informations.

  La capture MRZ n’est possible que si votre licence ABBYY FineReader Engine prend en charge le module [MRZCapture](/fr/fine-reader/engine/licensing/modules#mrzcapture).
</Accordion>

<Accordion title="Étape 3. Chargement et prétraitement des images du document">
  Pour charger des images dans FineReader Engine, vous pouvez utiliser les méthodes des objets suivants :

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

  <Note>
    Les utilisateurs de Linux et de Windows peuvent découvrir 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 se concentre sur FRDocument.
  </Note>

  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 à l’objet FRDocument créé à partir d’un fichier (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 prennent comme paramètre d’entrée un 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 d’image. Créez cet objet en appelant la méthode [IEngine::CreatePrepareImageMode](/fr/fine-reader/engine/api-reference/engine-object-iengine-interface/creation-methods/createlessobjectgreater-methods), puis modifiez ses propriétés selon les besoins et transmettez-le à la méthode d’ouverture de l’image.

  ### C\#

  ```csharp theme={null}
  // Créer le document
  FREngine.IFRDocument frDoc = engine.CreateFRDocument();
  // Ajouter le fichier image au document
  document.AddImageFile( imagePath, null, null );
  ```
</Accordion>

<Accordion title="Étape 4. Extraction des données de la MRZ">
  Pour extraire des données de la MRZ :

  1. \[facultatif] Créez l’objet [MrzProcessingParams](/fr/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/mrzprocessingparams) à l’aide de la méthode [CreateMrzProcessingParams](/fr/fine-reader/engine/api-reference/engine-object-iengine-interface/creation-methods/createlessobjectgreater-methods) de l’objet [Engine](/fr/fine-reader/engine/api-reference/engine-object-iengine-interface). Configurez ses propriétés avec les valeurs souhaitées.
  2. Appelez la méthode [ExtractMrz](/fr/fine-reader/engine/api-reference/document-related-objects/frpage/extractmrz-method) de l’objet [FRPage](/fr/fine-reader/engine/api-reference/document-related-objects/frpage), en passant l’objet [MrzProcessingParams](/fr/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/mrzprocessingparams) configuré à l’étape précédente en tant que paramètre d’entrée ; pour utiliser les paramètres de capture MRZ par défaut, passez simplement NULL. Vous recevrez un objet [MrzData](/fr/fine-reader/engine/api-reference/document-related-objects/mrzdata) contenant les informations analysées à partir de la MRZ capturée.

  ### C\#

  ```csharp theme={null}
  // Extraire la MRZ
  FREngine.IFRPage page = document.Pages.Item(0);
  FREngine.IMrzData mrzData = page.ExtractMrz( null );
  ```
</Accordion>

<Accordion title="Étape 5. Utilisation des données extraites">
  L’objet [MrzData](/fr/fine-reader/engine/api-reference/document-related-objects/mrzdata) contient toutes les données extraites de la MRZ. Vous pouvez accéder aux lignes de texte lisible par machine à l’aide de la méthode [GetLine](/fr/fine-reader/engine/api-reference/document-related-objects/mrzdata/getline-method) et parcourir les champs à l’aide des méthodes [GetField](/fr/fine-reader/engine/api-reference/document-related-objects/mrzdata/getfield-method) et [GetFieldByType](/fr/fine-reader/engine/api-reference/document-related-objects/mrzdata/getfieldbytype-method). Les champs des types suivants sont extraits :

  * Type de document
  * Sous-type de document
  * Pays de délivrance
  * Nom
  * Prénom
  * Numéro de document
  * Nationalité
  * Date de naissance
  * Sexe
  * Date d’expiration
  * Numéro personnel
  * Données facultatives, ligne 1
  * Données facultatives, ligne 2

  L’objet [MrzField](/fr/fine-reader/engine/api-reference/document-related-objects/mrzfield) fournit des informations complètes sur le champ extrait. Utilisez sa propriété [Text](/fr/fine-reader/engine/api-reference/document-related-objects/mrzfield#text) pour obtenir la valeur du champ et sa propriété [Region](/fr/fine-reader/engine/api-reference/document-related-objects/mrzfield#region) pour obtenir l’emplacement du champ dans l’image. Pour vérifier les données, utilisez les sommes de contrôle disponibles via les propriétés Checksum, HasChecksum et IsChecksumVerified des objets [MrzData](/fr/fine-reader/engine/api-reference/document-related-objects/mrzdata) et [MrzField](/fr/fine-reader/engine/api-reference/document-related-objects/mrzfield). Tous les types de champ ne prennent pas en charge les sommes de contrôle ; la propriété [HasChecksum](/fr/fine-reader/engine/api-reference/document-related-objects/mrzfield#haschecksum) vous permet d’en vérifier la valeur avant d’essayer de récupérer la somme de contrôle.

  Vous pouvez modifier manuellement le texte reconnu des champs à l’aide des méthodes [Insert](/fr/fine-reader/engine/api-reference/document-related-objects/mrzfield/insert-method) et [Remove](/fr/fine-reader/engine/api-reference/document-related-objects/mrzfield/remove-method) de l’objet [MrzField](/fr/fine-reader/engine/api-reference/document-related-objects/mrzfield).

  ### C\#

  ```csharp theme={null}
  // Vérifier la somme de contrôle du numéro de document
  FREngine.IMrzField documentNumberField = mrzData.GetFieldByType(FREngine.MrzFieldTypeEnum.MFT_DocumentNumber);
  bool isNumberVerified = documentNumberField.IsChecksumVerified;
  ```
</Accordion>

<Accordion title="Étape 6. Exportation des données extraites">
  Les données extraites peuvent être enregistrées dans un fichier XML ou JSON. Pour exporter les données avec les paramètres par défaut, appelez la méthode [ExportToFile](/fr/fine-reader/engine/api-reference/document-related-objects/mrzdata/exporttofile-method) de l’objet [MrzData](/fr/fine-reader/engine/api-reference/document-related-objects/mrzdata) et passez le chemin du fichier en paramètre d’entrée. Pour exporter les données avec des paramètres définis par l’utilisateur, appelez la méthode [ExportToFileEx](/fr/fine-reader/engine/api-reference/document-related-objects/mrzdata/exporttofileex-method) de l’objet [MrzData](/fr/fine-reader/engine/api-reference/document-related-objects/mrzdata) et passez en paramètre d’entrée le pointeur vers l’objet [MrzJsonExportParams](/fr/fine-reader/engine/api-reference/parameter-objects/export-parameters/mrzjsonexportparams) ou l’objet [MrzXmlExportParams](/fr/fine-reader/engine/api-reference/parameter-objects/export-parameters/mrzxmlexportparams).

  C#

  ```csharp theme={null}
  // Enregistrer au format XML
  mrzData.ExportToFile("C:\\ExtractedData.xml", FREngine.MrzExportFormatEnum.MEF_Xml);
  ```
</Accordion>

<Accordion title="Étape 7. Déchargement d’ABBYY FineReader Engine">
  Après avoir 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 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 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 vers FREngine.dll
      private IntPtr dllHandle = IntPtr.Zero;
      private InitializeEngine initializeEngine = null;
      private DeinitializeEngine deinitializeEngine = null;
      private DllCanUnloadNow dllCanUnloadNow = null;
  }
  ```
</Accordion>

<div id="required-resources">
  ## Ressources requises
</div>

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.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). Pour plus d’informations, consultez [Utilisation du fichier FREngineDistribution.csv](/fr/fine-reader/engine/distribution/distribution-windows/distribution-kit/working-with-the-frenginedistributioncsv-file).

<div id="additional-optimization">
  ## Optimisation supplémentaire
</div>

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

* Chargement d’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<br />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](/fr/fine-reader/engine/guided-tour/advanced-techniques/programming-aspects/using-in-server-applications) pour Windows<br />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)<br />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)<br />Personnalisation du traitement des documents à l’aide des objets de paramètre de prétraitement, d’analyse, de reconnaissance et de synthèse.
* Utilisation des données extraites
  * [Champs de zone lisible par machine](/fr/fine-reader/engine/specifications/machine-readable-zone-fields)<br />Liste des champs pouvant être extraits d’une zone lisible par machine à l’aide d’ABBYY FineReader Engine 12, ainsi que leur brève description.
  * [Utilisation du texte](/fr/fine-reader/engine/guided-tour/advanced-techniques/working-with-text)<br />Utilisation du texte reconnu, des paragraphes, des mots et des caractères.
  * [Utilisation de l’API Voting](/fr/fine-reader/engine/guided-tour/advanced-techniques/using-voting-api)<br />Utilisation des variantes de reconnaissance des mots et des caractères.

<div id="see-also">
  ## Voir aussi
</div>

[Mise en œuvre des scénarios d’utilisation de base](/fr/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation)