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

# Extraction de données

> Extrayez toutes les données — texte imprimé et manuscrit, tableaux, codes-barres, coches, images — d’un document avec ABBYY FineReader Engine et enregistrez-les au format JSON structuré.

Ce scénario sert à extraire toutes les données possibles d’un document et à les stocker de manière structurée.

Le résultat est un fichier JSON qui représente la structure du document. Il contient tous les objets du document : texte imprimé et manuscrit, tableaux, codes-barres, coches et images, avec leur emplacement et leurs attributs. Ce format est optimal pour un traitement ultérieur, le stockage des données dans une base de données ou l’intégration à une autre application.

Dans ce scénario, un document passe par plusieurs étapes de traitement :

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

   Les images obtenues à l’aide d’un scanner ou d’un appareil photo numérique peuvent nécessiter quelques ajustements avant de pouvoir être reconnues par OCR. Par exemple, les images bruitées ou celles dont les lignes de texte sont déformées doivent être corrigées pour que la reconnaissance optique soit efficace.

2. Extraction de toutes les données du document de manière structurée

   Lors de l’analyse de la mise en page, différents objets sont détectés dans l’image et regroupés en blocs du type correspondant. Les blocs sont reconnus selon les paramètres optimaux pour leur type. Lors de l’étape de synthèse, la structure logique du document est reconstituée de manière cohérente. L’ordre du texte est préservé, même pour les mises en page complexes, de façon à se rapprocher de l’ordre de lecture humain. Cela garantit qu’une nouvelle reconnaissance du même document produira le même ordre de lecture du texte.

3. Export vers un format structuré

   Le document reconnu est enregistré au format JSON ou XML.

<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 afin d’extraire les données des documents. Cette méthode s’appuie sur les paramètres de traitement les mieux adaptés à cet usage.

<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 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). Consultez également [les autres méthodes de chargement de 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, assignez des chaînes vides à ces variables
  wchar_t* LicensePassword;
  // HANDLE vers FREngine.dll
  static HMODULE libraryHandle = 0;
  // Objet Engine FineReader 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 : récupérer 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";
      }
  }
  ```
</Accordion>

<Accordion title="Étape 2. Chargement des paramètres du scénario">
  ABBYY FineReader Engine permet de charger tous les paramètres de traitement les mieux 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](/fr/fine-reader/engine/api-reference/engine-object-iengine-interface). Cette méthode prend en entrée le nom du profil. Veuillez consulter [Working with Profiles](/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 [DataExtraction](/fr/fine-reader/engine/guided-tour/advanced-techniques/working-with-profiles#dataextraction) :

  * L’analyse de la mise en page et la reconnaissance privilégient la précision plutôt que la vitesse.
  * Détecte tout le texte d’une image, y compris le texte manuscrit et les petites zones de texte de faible qualité.
  * Détecte les tableaux, les coches et les codes-barres.
  * Effectue une synthèse complète de la structure logique d’un document.

  ### C\#

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

  ### C++ (COM)

  ```cpp theme={null}
  // Charger un profil prédéfini
  Engine->LoadPredefinedProfile( L"DataExtraction" );
  ```

  Si vous souhaitez modifier les paramètres de traitement, utilisez les objets Parameter correspondants. Veuillez consulter la section [Additional optimization](/fr/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation/data-extraction#optimization) ci-dessous pour plus d’informations.
</Accordion>

<Accordion title="Étape 3. Chargement et prétraitement des images">
  ABBYY FineReader Engine fournit l’objet [FRDocument](/fr/fine-reader/engine/api-reference/document-related-objects/frdocument), qui permet de traiter des documents multipages. L’utilisation de cet objet vous permet de préserver l’organisation logique du document, en conservant le texte d’origine ainsi que les colonnes, polices, styles, etc.

  Pour charger et prétraiter les images d’un même document, vous devez créer l’objet FRDocument et y ajouter des images. Vous pouvez procéder de l’une des manières suivantes :

  * Créez l’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 l’objet FRDocument et charge les images à partir du fichier spécifié.
  * Créez l’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 ajoutez des images au 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) 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}
  // Créer l’objet FRDocument à partir d’un fichier image
  FREngine::IFRDocumentPtr frDocument = Engine->CreateFRDocumentFromImage( L"C:\\MyImage.tif", 0 );
  ```
</Accordion>

<Accordion title="Étape 4. Reconnaissance du document">
  Pour reconnaître un document, nous vous recommandons d’utiliser les méthodes d’analyse et de reconnaissance de l’objet FRDocument. Cet objet offre toute une série de méthodes pour l’analyse, la reconnaissance et la synthèse de documents. La méthode la plus pratique, qui regroupe en une seule opération l’analyse, la reconnaissance et la synthèse du document, est la méthode [Process](/fr/fine-reader/engine/api-reference/document-related-objects/frdocument/process-method). Elle exploite également de la manière la plus efficace les fonctionnalités de traitement simultané des systèmes multiprocesseurs et multicœurs. Toutefois, vous pouvez aussi effectuer successivement le prétraitement, l’analyse, la reconnaissance et la synthèse à l’aide des méthodes [Preprocess](/fr/fine-reader/engine/api-reference/document-related-objects/frdocument/preprocess-method), [Analyze](/fr/fine-reader/engine/api-reference/document-related-objects/frdocument/analyze-method), [Recognize](/fr/fine-reader/engine/api-reference/document-related-objects/frdocument/recognize-method) et [Synthesize](/fr/fine-reader/engine/api-reference/document-related-objects/frdocument/synthesize-method).

  ### C\#

  ```csharp theme={null}
  // Analyser, reconnaître et synthétiser le document
  // Il n’est pas nécessaire de fournir de paramètres supplémentaires, car ils sont définis par le profil de traitement
  frDocument.Process( null );
  ```

  ### C++ (COM)

  ```cpp theme={null}
  // Analyser, reconnaître et synthétiser le document
  // Il n’est pas nécessaire de fournir de paramètres supplémentaires, car ils sont définis par le profil de traitement
  frDocument->Process( 0 );
  ```
</Accordion>

<Accordion title="Étape 5. Exportation du document">
  Pour enregistrer un document reconnu, 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 passant la constante [FileExportFormatEnum](/fr/fine-reader/engine/api-reference/enumerations/fileexportformatenum) comme l’un des paramètres. Vous pouvez modifier les paramètres d’exportation par défaut à l’aide de l’objet d’exportation correspondant. Consultez la section [Optimisation supplémentaire pour des tâches spécifiques](/fr/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation/document-conversion#optimization) ci-dessous pour plus d’informations.

  Une fois que vous avez terminé d’utiliser l’objet FRDocument, libérez toutes les ressources employé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}
  // Enregistrer le document reconnu dans un format structuré
  frDocument.Export( "C:\\Data.json", FREngine.FileExportFormatEnum.FEF_JSON, null );
  // Libérer l’objet FRDocument
  frDocument.Close();
  ```

  ### C++ (COM)

  ```cpp theme={null}
  // Enregistrer le document reconnu dans un format structuré
  frDocument->Export( L"C:\\Data.json", FREngine::FEF_JSON, 0 );
  // Libérer l’objet FRDocument
  frDocument->Close();
  ```
</Accordion>

<Accordion title="Étape 6. Déchargement d’ABBYY FineReader Engine">
  Une fois que vous avez terminé 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 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"Erreur lors du déchargement d’ABBYY FineReader Engine";
   }
   // Vous pouvez maintenant libérer la bibliothèque FREngine.dll en toute sécurité
   FreeLibrary( libraryHandle );
   libraryHandle = 0;
  }
  ```
</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 la 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 utilisateur, les langues de reconnaissance et toutes les fonctionnalités supplémentaires utilisées par votre application (comme, 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.

<div id="additional-optimization-for-specific-tasks">
  ## Optimisation supplémentaire pour des tâches spécifiques
</div>

Vous trouverez ci-dessous un aperçu des rubriques d’aide contenant des informations complémentaires sur la personnalisation des paramètres aux différentes étapes de la conversion d’un document dans un format modifiable :

* Numérisation - *Windows uniquement*
  * [Numérisation](/fr/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation/scanning)<br />Description du scénario ABBYY FineReader Engine pour la numérisation de documents.
* 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 d’objets de paramètres d’analyse, de reconnaissance et de synthèse.
  * [PageProcessingParams Object](/fr/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/pageprocessingparams)<br />Cet objet permet de personnaliser les paramètres d’analyse et de reconnaissance. À l’aide de cet objet, vous pouvez indiquer quelles caractéristiques de l’image et du texte doivent être détectées (image inversée, orientation, code-barres, langue de reconnaissance, marge d’erreur de reconnaissance).
  * [SynthesisParamsForPage Object](/fr/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/synthesisparamsforpage)<br />Cet objet inclut les paramètres responsables de la restitution de la mise en forme d’une page lors de la synthèse.
  * [SynthesisParamsForDocument Object](/fr/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/synthesisparamsfordocument)<br />Cet objet permet de personnaliser la synthèse du document : restitution de sa structure et de sa mise en forme.
  * [MultiProcessingParams Object](/fr/fine-reader/engine/api-reference/parameter-objects/multiprocessingparams) - *Implémenté pour Linux et Windows* <br />Le traitement simultané peut être utile lors du traitement d’un grand nombre d’images. Dans ce cas, la charge de traitement est répartie entre les cœurs du processeur pendant l’ouverture et le prétraitement des images, l’analyse de la mise en page, la reconnaissance et l’exportation, ce qui permet d’accélérer le traitement.<br />Les modes de traitement (simultané ou consécutif) sont définis à l’aide de la propriété MultiProcessingMode. La propriété RecognitionProcessesCount contrôle le nombre de processus pouvant être démarrés.
* Exportation
  * [Réglage des paramètres d’exportation](/fr/fine-reader/engine/guided-tour/advanced-techniques/tuning-export-parameters)<br />Personnalisation de l’exportation du document à l’aide d’objets de paramètres d’exportation.
  * [XMLExportParams Object](/fr/fine-reader/engine/api-reference/parameter-objects/export-parameters/xmlexportparams)<br />Cet objet fournit les paramètres d’exportation au format XML.
  * [JsonExportParams Object](/fr/fine-reader/engine/api-reference/parameter-objects/export-parameters/jsonexportparams)<br />Cet objet fournit les paramètres d’exportation au format JSON.

<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)