Passer au contenu principal
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 (voir les spécifications sur le site web 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.
  1. 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.
  1. 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 pour Linux et Windows.

​
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 12 dans ce scénario. Cette méthode s’appuie sur les paramètres de traitement les mieux adaptés à 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 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 également d’autres façons de 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 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;
}
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 utilise comme paramètre d’entrée le nom d’un profil de paramètres. Veuillez consulter Utilisation des profils pour plus d’informations.Les paramètres de ce scénario sont disponibles dans le profil prédéfini 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#

// 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 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.
Pour charger des images dans FineReader Engine, vous pouvez utiliser les méthodes des objets suivants :
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. Cette rubrique se concentre sur FRDocument.
Pour charger des images dans l’objet FRDocument, effectuez l’une des opérations suivantes :Toutes ces méthodes prennent comme paramètre d’entrée un objet 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, puis modifiez ses propriétés selon les besoins et transmettez-le à la méthode d’ouverture de l’image.

​
C#

// Créer le document
FREngine.IFRDocument frDoc = engine.CreateFRDocument();
// Ajouter le fichier image au document
document.AddImageFile( imagePath, null, null );
Pour extraire des données de la MRZ :
  1. [facultatif] Créez l’objet MrzProcessingParams à l’aide de la méthode CreateMrzProcessingParams de l’objet Engine. Configurez ses propriétés avec les valeurs souhaitées.
  2. Appelez la méthode ExtractMrz de l’objet FRPage, en passant l’objet 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 contenant les informations analysées à partir de la MRZ capturée.

​
C#

// Extraire la MRZ
FREngine.IFRPage page = document.Pages.Item(0);
FREngine.IMrzData mrzData = page.ExtractMrz( null );
L’objet 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 et parcourir les champs à l’aide des méthodes GetField et GetFieldByType. 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 fournit des informations complètes sur le champ extrait. Utilisez sa propriété Text pour obtenir la valeur du champ et sa propriété 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 et MrzField. Tous les types de champ ne prennent pas en charge les sommes de contrôle ; la propriété 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 et Remove de l’objet MrzField.

​
C#

// 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;
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 de l’objet 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 de l’objet MrzData et passez en paramètre d’entrée le pointeur vers l’objet MrzJsonExportParams ou l’objet MrzXmlExportParams.C#
// Enregistrer au format XML
mrzData.ExportToFile("C:\\ExtractedData.xml", FREngine.MrzExportFormatEnum.MEF_Xml);
Après avoir 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 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;
}

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

​
Optimisation supplémentaire

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 :

​
Voir aussi

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