Reconnaissance des Barcode

Dans ce scénario, ABBYY FineReader Engine est utilisé pour lire des Barcode. La lecture des Barcode peut être nécessaire, par exemple, pour la séparation automatique de documents, le traitement de documents par un système de gestion documentaire, ou encore l’indexation et la classification de documents.

Ce scénario peut être utilisé dans le cadre d’autres scénarios. Par exemple, des documents numérisés à l’aide de scanners de production haute vitesse peuvent être séparés au moyen de Barcode, ou des documents préparés pour un archivage à long terme peuvent être versés dans des systèmes de gestion documentaire d’archivage en fonction des valeurs de leurs Barcode.

Lors de l’extraction de Barcode à partir de textes, le système peut détecter tous les Barcode ou uniquement les Barcode d’un certain type ayant une certaine valeur. Le système peut extraire la valeur d’un Barcode et calculer sa somme de contrôle. Pour obtenir les résultats les plus rapides et de la meilleure qualité en reconnaissance de Barcode :

1. Utilisez des images couleur avec une résolution optimale de 300 dpi.

2. Réglez la vitesse de reconnaissance à l’aide de profils (voir Utilisation des profils pour plus de détails).

Les valeurs des Barcode reconnus peuvent être enregistrées dans les formats les plus pratiques pour un traitement ultérieur, par exemple au format TXT.

​

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 jugés les plus appropriés pour ce scénario.

Étape 1. Chargement d’ABBYY FineReader Engine

Pour commencer à utiliser ABBYY FineReader Engine, vous devez créer l’objet Engine. L’objet Engine est l’objet de plus haut niveau dans la hiérarchie des objets ABBYY FineReader Engine ; il 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 les 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 de licence en ligne et le mot de passe de la licence en ligne
        string enginePath = "";
        string customerProjectId = "";
        string licensePath = "";
        string licensePassword = "";
        // Chargement de la bibliothèque FREngine.dll
        dllHandle = LoadLibraryEx(enginePath, IntPtr.Zero, LOAD_WITH_ALTERED_SEARCH_PATH);
           
        try
        {
            if (dllHandle == IntPtr.Zero)
            {
                throw new Exception("Impossible de charger " + enginePath);
            }
            IntPtr initializeEnginePtr = GetProcAddress(dllHandle, "InitializeEngine");
            if (initializeEnginePtr == IntPtr.Zero)
            {
                throw new Exception("Impossible de trouver la fonction InitializeEngine");
            }
            IntPtr deinitializeEnginePtr = GetProcAddress(dllHandle, "DeinitializeEngine");
            if (deinitializeEnginePtr == IntPtr.Zero)
            {
                throw new Exception("Impossible de trouver la fonction DeinitializeEngine");
            }
            IntPtr dllCanUnloadNowPtr = GetProcAddress(dllHandle, "DllCanUnloadNow");
            if (dllCanUnloadNowPtr == IntPtr.Zero)
            {
                throw new Exception("Impossible de trouver la fonction DllCanUnloadNow");
            }
            // Conversion des 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));
            // Appel de la fonction InitializeEngine
            // en 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ération de 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 vers FREngine.dll
    private IntPtr dllHandle = IntPtr.Zero;
    private InitializeEngine initializeEngine = null;
    private DeinitializeEngine deinitializeEngine = null;
    private DllCanUnloadNow dllCanUnloadNow = null;
}

​

C++ (COM)

// Initialisez ces variables avec le chemin vers FREngine.dll, votre Customer Project ID FineReader Engine,
// et, le cas échéant, le chemin vers le jeton de licence en ligne et le mot de passe de la licence en ligne
wchar_t* FreDllPath;
wchar_t* CustomerProjectId;
wchar_t* LicensePath;  // si vous n'utilisez pas de licence en ligne, affectez des chaînes vides à ces variables
wchar_t* LicensePassword;
// HANDLE vers FREngine.dll
static HMODULE libraryHandle = 0;
// Objet FineReader Engine global
FREngine::IEnginePtr Engine;
void LoadFREngine()
{
    if( Engine != 0 ) {
    // Déjà chargé
    return;
    }
    // Première étape : charger FREngine.dll
    if( libraryHandle == 0 ) {
        libraryHandle = LoadLibraryEx( FreDllPath, 0, LOAD_WITH_ALTERED_SEARCH_PATH );
        if( libraryHandle == 0 ) {
            throw L"Erreur lors du chargement d'ABBYY FineReader Engine";
        }
    }
    // Deuxième étape : obtenir l'objet Engine
    typedef HRESULT ( STDAPICALLTYPE* InitializeEngineFunc )( BSTR, BSTR, BSTR, BSTR, 
        BSTR, VARIANT_BOOL, FREngine::IEngine** );
    InitializeEngineFunc pInitializeEngine =
    ( InitializeEngineFunc )GetProcAddress( libraryHandle, "InitializeEngine" );
    if( pInitializeEngine == 0 || pInitializeEngine( CustomerProjectId, LicensePath, 
        LicensePassword, L"", L"", VARIANT_FALSE, &Engine ) != S_OK ) {
    UnloadFREngine();
    throw L"Erreur lors du chargement d'ABBYY FineReader Engine";
    }
}

Étape 2. Chargement des paramètres du scénario

Les paramètres les mieux adaptés peuvent être sélectionnés à l’aide de la méthode LoadPredefinedProfile de l’objet Engine. Cette méthode prend en paramètre le nom du profil de paramètres à utiliser. Pour en savoir plus sur les profils, consultez Utilisation des profils.

ABBYY FineReader Engine prend en charge 2 variantes de paramètres pour ce scénario :

Nom du profil	Description
BarcodeRecognition_Accuracy	Extrait uniquement les Barcode (les textes, images et tableaux ne sont pas détectés). Les paramètres ont été optimisés pour la précision. Ce profil nécessite le module Barcode Autolocation inclus dans la licence.
BarcodeRecognition_Speed	Extrait uniquement les Barcode (les textes, images et tableaux ne sont pas détectés). Les paramètres ont été optimisés pour la vitesse de traitement. Ce profil nécessite le module Barcode Autolocation inclus dans la licence.

​

C#

// Charger un profil prédéfini
engine.LoadPredefinedProfile("BarcodeRecognition_Speed");

​

C++ (COM)

// Charger un profil prédéfini
Engine->LoadPredefinedProfile( L"BarcodeRecognition_Speed" );

Si vous souhaitez modifier les paramètres utilisés pour le traitement, utilisez les objets Parameter appropriés. Pour plus d’informations, consultez la section Optimisation supplémentaire ci-dessous.

Étape 3. Chargement et prétraitement des images

ABBYY FineReader Engine fournit un objet FRDocument pour traiter des documents multipages. Pour charger les images d’un document et les prétraiter, vous devez créer l’objet FRDocument et y ajouter les images. Vous pouvez procéder de l’une des façons suivantes :

• Créer un objet FRDocument à l’aide de la méthode CreateFRDocumentFromImage de l’objet Engine. Cette méthode crée un objet FRDocument et charge les images à partir du fichier spécifié.
• Créer un objet FRDocument à l’aide de la méthode CreateFRDocument de l’objet Engine, puis ajouter les images à l’objet FRDocument créé à partir d’un fichier (utilisez les méthodes AddImageFile, AddImageFileWithPassword ou AddImageFileWithPasswordCallback de l’objet FRDocument).

​

C#

// Créer l'objet FRDocument à partir d'un fichier image
FREngine.IFRDocument frDocument = engine.CreateFRDocumentFromImage( "C:\\MyImage.tif", null );

​

C++ (COM)

// Ouvrir un fichier image et créer l'objet FRDocument
FREngine::IFRDocumentPtr frDocument = Engine->CreateFRDocumentFromImage( L"C:\\MyImage.tif", 0 );

Étape 4. Extraction des Barcode

Si le profil BarcodeRecognition est chargé, vous pouvez utiliser la méthode Process de l’objet FRDocument pour extraire uniquement les Barcode. Dans ce cas, ABBYY FineReader Engine détecte uniquement les blocs contenant des Barcode. Aucun autre bloc n’est détecté. Les blocs de Barcode reconnus sont accessibles via l’objet Layout, qui est un sous-objet de l’objet FRPage, représentant une page du document.

Pour lire des Barcode d’un type spécifique, spécifiez les paramètres appropriés de l’objet BarcodeParams et transmettez l’objet BarcodeParams comme paramètre à l’une des fonctions ci-dessus.

​

C#

// Si le profil BarcodeRecognition est chargé,
// vous n’avez pas besoin de transmettre de paramètres supplémentaires à la méthode de traitement
// si les codes-barres sont conformes aux spécifications
frDocument.Process( null );
// Si vous devez lire des codes-barres d’un type spécifique
// Créez un objet DocumentProcessingParams
FREngine.IDocumentProcessingParams dpp = engine.CreateDocumentProcessingParams();
// Spécifiez les paramètres nécessaires
dpp.PageProcessingParams.PageAnalysisParams.BarcodeParams.Type = ( int )FREngine.BarcodeTypeEnum.BT_Code39;
// Lancez maintenant la reconnaissance des codes-barres avec ces paramètres
frDocument.Process( dpp );

​

C++ (COM)

// Si le profil BarcodeRecognition est chargé,
// vous n’avez pas besoin de transmettre de paramètres supplémentaires à la méthode de traitement
// si les codes-barres sont conformes aux spécifications
frDocument->Process( 0 );
// Si vous devez lire des codes-barres d’un type spécifique
// Créez un objet DocumentProcessingParams
FREngine::IDocumentProcessingParamsPtr params = Engine->CreateDocumentProcessingParams();
// Spécifiez les paramètres nécessaires
params->PageProcessingParams->PageAnalysisParams->BarcodeParams->Type = FREngine::BT_Code39;
// Lancez maintenant la reconnaissance des codes-barres avec ces paramètres
frDocument->Process( params );

Étape 5. Exportation des données reconnues

Pour enregistrer les valeurs des Barcode reconnus dans un fichier, vous pouvez utiliser la méthode Export de l’objet FRDocument en indiquant la constante FileExportFormatEnum comme l’un des paramètres. Dans ce scénario, l’exportation peut être effectuée, par exemple, au format TXT. Vous pouvez modifier les paramètres d’exportation par défaut à l’aide de l’objet d’exportation correspondant. Consultez Optimisation supplémentaire pour des tâches spécifiques ci-dessous pour plus d’informations.

Après avoir terminé votre travail avec l’objet FRDocument, libérez toutes les ressources utilisées par cet objet. Utilisez la méthode IFRDocument::Close.

​

C#

// Enregistrez les codes-barres reconnus dans un format donné (par exemple, TXT)
frDocument.Export( "C:\\barcodes.txt", FREngine.FileExportFormatEnum.FEF_TextUnicodeDefaults, null );
// Libérez l’objet FRDocument
frDocument.Close();

​

C++ (COM)

// Enregistrez les codes-barres reconnus dans un format donné (par exemple, TXT)
frDocument->Export( L"C:\\barcodes.txt", FREngine::FEF_TextUnicodeDefaults, 0 );
// Libérez l’objet FRDocument
frDocument->Close();

Étape 6. Déchargement d’ABBYY FineReader Engine

Après avoir terminé votre travail avec 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;
}

​

C++ (COM)

void UnloadFREngine()
{
 if( libraryHandle == 0 ) {
  return;
 }
 // Libérer l’objet Engine
 Engine = 0;
 // Désinitialiser FineReader Engine
 typedef HRESULT ( STDAPICALLTYPE* DeinitializeEngineFunc )();
 DeinitializeEngineFunc pDeinitializeEngine =
  ( DeinitializeEngineFunc )GetProcAddress( libraryHandle, "DeinitializeEngine" );
 if( pDeinitializeEngine == 0 || pDeinitializeEngine() != S_OK ) {
  throw L"Error while unloading ABBYY FineReader Engine";
 }
 // Vous pouvez maintenant libérer la bibliothèque FREngine.dll en toute sécurité
 FreeLibrary( libraryHandle );
 libraryHandle = 0;
}

​

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 avec 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, ou Processing.OCR.CJK si vous devez reconnaître des textes dans les 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 des différentes étapes de traitement :

• Extraction et lecture des Barcodes
  • Objet BarcodeParams
    Cet objet vous permet de configurer les paramètres d’analyse et de lecture des Barcodes.
  • Reconnaissance des Barcodes
    Cette section traite des cas particuliers de reconnaissance des Barcodes et fournit des conseils pour travailler avec eux.
  • Types de Barcodes
    Liste des Barcodes pris en charge dans ABBYY FineReader Engine 12 et brève description de chacun.
  • Objet FRDocument
    Outre les valeurs des Barcodes, vous pouvez avoir besoin d’extraire d’autres informations contenues dans le document. Dans ce cas, vous pouvez utiliser les méthodes de l’objet FRDocument.
  • Objet PageProcessingParams
    Cet objet vous permet de configurer les paramètres d’analyse et de reconnaissance pour l’ensemble du document. Il vous permet également d’indiquer si les valeurs des Barcodes doivent être reconnues. Les paramètres de lecture des Barcodes sont accessibles via les propriétés BarcodeParams et DetectBarcodes du sous-objet PageAnalysisParams.
  • Utilisation de Layout et des blocs
    Vous pouvez également marquer manuellement des blocs de Barcode et spécifier leurs paramètres d’analyse et de lecture. Cette section fournit des informations détaillées sur l’utilisation des blocs.
• Utilisation des valeurs de Barcode reconnues
  • Objet BarcodeBlock
    Les propriétés Text et BarcodeText de cet objet contiennent la valeur du Barcode obtenue par reconnaissance. Les autres propriétés de cet objet peuvent être utilisées pour obtenir le type de Barcode, son orientation et d’autres paramètres.
• Exportation
  • Réglage des paramètres d’exportation
    Configuration de l’exportation à l’aide des objets de paramètres d’exportation.
  • Objet TextExportParams
    Cet objet vous permet de configurer l’enregistrement des résultats de reconnaissance au format TXT.

​

Voir aussi

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