> ## 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 des Barcode
> Utilisez ABBYY FineReader Engine pour lire des Barcode à des fins de séparation de documents, d’indexation et de classification — réglez la vitesse et la précision avec le profil BarcodeRecognition.
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](/fr/fine-reader/engine/guided-tour/advanced-techniques/working-with-profiles) 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.
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 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](/fr/fine-reader/engine/api-reference/functions/initializeengine-function). Voir aussi [les 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 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)
```cpp theme={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 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";
}
}
```
Les paramètres les mieux adaptés peuvent être sélectionnés à 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](/fr/fine-reader/engine/api-reference/engine-object-iengine-interface). 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](/fr/fine-reader/engine/guided-tour/advanced-techniques/working-with-profiles).
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](/fr/fine-reader/engine/licensing/modules#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](/fr/fine-reader/engine/licensing/modules#barcode_autolocation) inclus dans la licence. |
### C\#
```csharp theme={null}
// Charger un profil prédéfini
engine.LoadPredefinedProfile("BarcodeRecognition_Speed");
```
### C++ (COM)
```cpp theme={null}
// 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](/fr/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation/barcode-recognition#optimization) ci-dessous.
ABBYY FineReader Engine fournit un objet [FRDocument](/fr/fine-reader/engine/api-reference/document-related-objects/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](/fr/fine-reader/engine/api-reference/engine-object-iengine-interface/creation-methods/createfrdocumentfromimage-method) 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](/fr/fine-reader/engine/api-reference/engine-object-iengine-interface/creation-methods/createlessobjectgreater-methods) de l’objet Engine, puis ajouter les images à l’objet FRDocument créé à partir d’un fichier (utilisez les méthodes [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) de l’objet FRDocument).
### C\#
```csharp theme={null}
// Créer l'objet FRDocument à partir d'un fichier image
FREngine.IFRDocument frDocument = engine.CreateFRDocumentFromImage( "C:\\MyImage.tif", null );
```
### C++ (COM)
```cpp theme={null}
// Ouvrir un fichier image et créer l'objet FRDocument
FREngine::IFRDocumentPtr frDocument = Engine->CreateFRDocumentFromImage( L"C:\\MyImage.tif", 0 );
```
Si le profil BarcodeRecognition est chargé, vous pouvez utiliser la méthode [Process](/fr/fine-reader/engine/api-reference/document-related-objects/frdocument/process-method) 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](/fr/fine-reader/engine/api-reference/layout-related-objects/layout), qui est un sous-objet de l’objet [FRPage](/fr/fine-reader/engine/api-reference/document-related-objects/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](/fr/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/barcodeparams) et transmettez l’objet BarcodeParams comme paramètre à l’une des fonctions ci-dessus.
### C\#
```csharp theme={null}
// 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)
```cpp theme={null}
// 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 );
```
Pour enregistrer les valeurs des Barcode reconnus dans un fichier, vous pouvez utiliser la méthode [Export](/fr/fine-reader/engine/api-reference/document-related-objects/frdocument/export-method) de l’objet [FRDocument](/fr/fine-reader/engine/api-reference/document-related-objects/frdocument) en indiquant la constante [FileExportFormatEnum](/fr/fine-reader/engine/api-reference/enumerations/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](/fr/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation/barcode-recognition#optimization) 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](/fr/fine-reader/engine/api-reference/document-related-objects/frdocument/close-method).
### C\#
```csharp theme={null}
// 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)
```cpp theme={null}
// 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();
```
Après avoir terminé votre travail avec 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;
}
```
### C++ (COM)
```cpp theme={null}
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](/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 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](/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 des différentes étapes de traitement :
* Extraction et lecture des Barcodes
* [Objet BarcodeParams](/fr/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/barcodeparams)
Cet objet vous permet de configurer les paramètres d’analyse et de lecture des Barcodes.
* [Reconnaissance des Barcodes](/fr/fine-reader/engine/guided-tour/advanced-techniques/recognizing-barcodes)
Cette section traite des cas particuliers de reconnaissance des Barcodes et fournit des conseils pour travailler avec eux.
* [Types de Barcodes](/fr/fine-reader/engine/specifications/barcode-types)
Liste des Barcodes pris en charge dans ABBYY FineReader Engine 12 et brève description de chacun.
* [Objet FRDocument](/fr/fine-reader/engine/api-reference/document-related-objects/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](/fr/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/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](/fr/fine-reader/engine/guided-tour/advanced-techniques/working-with-layout-and-blocks)
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](/fr/fine-reader/engine/api-reference/layout-related-objects/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](/fr/fine-reader/engine/guided-tour/advanced-techniques/tuning-export-parameters)
Configuration de l’exportation à l’aide des objets de paramètres d’exportation.
* [Objet TextExportParams](/fr/fine-reader/engine/api-reference/parameter-objects/export-parameters/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](/fr/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation)