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 :
Utilisez des images couleur avec une résolution optimale de 300 dpi.
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.
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).
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;}
// 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 lignewchar_t* FreDllPath;wchar_t* CustomerProjectId;wchar_t* LicensePath; // si vous n'utilisez pas de licence en ligne, affectez des chaînes vides à ces variableswchar_t* LicensePassword;// HANDLE vers FREngine.dllstatic HMODULE libraryHandle = 0;// Objet FineReader Engine globalFREngine::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. <Warning> Ce profil nécessite le module Barcode Autolocation inclus dans la licence. </Warning>
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. <Warning> Ce profil nécessite le module Barcode Autolocation inclus dans la licence. </Warning>
// Charger un profil prédéfiniEngine->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é.
// Ouvrir un fichier image et créer l'objet FRDocumentFREngine::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.
// 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écificationsfrDocument.Process( null );// Si vous devez lire des codes-barres d’un type spécifique// Créez un objet DocumentProcessingParamsFREngine.IDocumentProcessingParams dpp = engine.CreateDocumentProcessingParams();// Spécifiez les paramètres nécessairesdpp.PageProcessingParams.PageAnalysisParams.BarcodeParams.Type = ( int )FREngine.BarcodeTypeEnum.BT_Code39;// Lancez maintenant la reconnaissance des codes-barres avec ces paramètresfrDocument.Process( dpp );
// 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écificationsfrDocument->Process( 0 );// Si vous devez lire des codes-barres d’un type spécifique// Créez un objet DocumentProcessingParamsFREngine::IDocumentProcessingParamsPtr params = Engine->CreateDocumentProcessingParams();// Spécifiez les paramètres nécessairesparams->PageProcessingParams->PageAnalysisParams->BarcodeParams->Type = FREngine::BT_Code39;// Lancez maintenant la reconnaissance des codes-barres avec ces paramètresfrDocument->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.
// 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 FRDocumentfrDocument.Close();
// 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 FRDocumentfrDocument->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.
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 :CoreCore.ResourcesOpeningOpening, ProcessingProcessingProcessing.OCRProcessing.OCR, Processing.ICRProcessing.OCR.NaturalLanguagesProcessing.OCR.NaturalLanguages, Processing.ICR.NaturalLanguagesExportExport, ProcessingSi 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.
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.
