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

> Extrayez le corps du texte d’un document avec ABBYY FineReader Engine dans l’ordre naturel de lecture, prêt à être transmis à des moteurs NLP pour le résumé, la recherche ou l’analyse des sentiments.

Ce scénario permet d’extraire le corps du texte d’un document ainsi que les textes figurant sur les logos, les sceaux et tout autre élément en dehors du corps du texte.

L’ordre naturel du texte, « comme le lirait un humain », est préservé. Vous pouvez ensuite transmettre les documents à vos moteurs de traitement du langage naturel (NLP), par exemple pour les résumer rapidement, y rechercher des informations sensibles ou effectuer une analyse des sentiments.

Pour extraire le texte principal du document, 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

   Les images numérisées peuvent nécessiter un prétraitement avant la reconnaissance, par exemple si les documents numérisés contiennent du bruit de fond, du texte incliné, des couleurs inversées, des marges noires, une orientation incorrecte ou une résolution inadéquate.

2. Reconnaissance du maximum de texte dans l’image d’un document

   La reconnaissance des images est effectuée à l’aide de paramètres garantissant que tout le texte possible est détecté et extrait de l’image du document.

<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 dans ce scénario. Cette méthode s’appuie sur des paramètres de traitement particulièrement adaptés à ce scénario.

<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 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 : 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">
  Les paramètres les mieux adaptés à ce scénario peuvent être sélectionnés dans ABBYY FineReader Engine à 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 [Utilisation des profils](/fr/fine-reader/engine/guided-tour/advanced-techniques/working-with-profiles) pour plus d’informations.

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

  <table><thead><tr><th><p><strong>Nom du profil</strong></p></th><th><p><strong>Description</strong></p></th></tr></thead><tbody><tr><td><p><em>TextExtraction\_Accuracy</em></p></td><td><p>Les paramètres ont été optimisés pour la précision :</p><ul><li>Active la détection de tout le texte d’une image, y compris les petites zones de texte de faible qualité (les images et les tableaux ne sont pas détectés).</li><li>La synthèse complète de la structure logique d’un document n’est pas effectuée.</li></ul><Warning>Le profil n’est pas destiné à la conversion d’un document en RTF, DOCX ou PDF contenant uniquement du texte. Utilisez les profils de conversion de documents à cette fin.</Warning></td></tr><tr><td><p><em>TextExtraction\_Speed</em></p></td><td><p>Les paramètres ont été optimisés pour la vitesse de traitement :</p><ul><li>Active la détection de tout le texte d’une image, y compris les petites zones de texte de faible qualité (les images et les tableaux ne sont pas détectés).</li><li>La synthèse complète de la structure logique d’un document n’est pas effectuée.</li><li>Les processus d’analyse et de reconnaissance du document sont accélérés.</li></ul><Warning>Le profil n’est pas destiné à la conversion d’un document en RTF, DOCX ou PDF contenant uniquement du texte. Utilisez les profils de conversion de documents à cette fin.</Warning></td></tr></tbody></table>

  ### C\#

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

  ### C++ (COM)

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

  Si vous souhaitez modifier les paramètres de traitement, utilisez les objets de paramètres appropriés. Veuillez consulter [Optimisation supplémentaire pour des tâches spécifiques](/fr/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation/text-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.

  Pour charger les images d’un seul document et les prétraiter, 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-y des images à 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}
  // Ouvrir un fichier image et créer l'objet FRDocument
  FREngine::IFRDocumentPtr frDocument = Engine->CreateFRDocumentFromImage( L"C:\\MyImage.tif", 0 );
  ```
</Accordion>

<Accordion title="Étape 4. Reconnaissance du document">
  Pour reconnaître le document, vous devez utiliser les méthodes d’analyse et de reconnaissance de l’objet [FRDocument](/fr/fine-reader/engine/api-reference/document-related-objects/frdocument). Cet objet offre tout un ensemble de méthodes pour l’analyse et la reconnaissance de documents. La méthode la plus pratique, qui permet d’effectuer l’analyse, la reconnaissance et la synthèse en un seul appel, est [Process](/fr/fine-reader/engine/api-reference/document-related-objects/frdocument/process-method). Elle exploite également de la manière la plus efficace les capacités de traitement simultané des systèmes multiprocesseurs et multicœurs. Toutefois, vous pouvez aussi exécuter 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
  // Aucun paramètre supplémentaire n’est nécessaire, 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
  // Une fois le profil chargé, vous n’avez pas besoin de transmettre de paramètres supplémentaires à la méthode de traitement
  frDocument->Process( 0 );
  ```
</Accordion>

<Accordion title="Étape 5. Recherche d’informations importantes">
  Lors de l’analyse, ABBYY FineReader Engine sélectionne les blocs d’image contenant du texte, des tableaux, des images, etc. Au cours de la reconnaissance, les blocs contenant des données textuelles sont remplis avec le texte reconnu.

  Dans ABBYY FineReader Engine, l’objet [Layout](/fr/fine-reader/engine/api-reference/layout-related-objects/layout) sert à stocker les blocs et le texte reconnu. Dans le scénario principal de traitement des documents, le Layout est utilisé dans l’objet [FRDocument](/fr/fine-reader/engine/api-reference/document-related-objects/frdocument), qui représente le document en cours de traitement. Pour accéder au Layout d’une page de document, utilisez la propriété [IFRPage::Layout](/fr/fine-reader/engine/api-reference/document-related-objects/frpage).

  Pour rechercher des mots-clés, vous pouvez consulter le texte reconnu à l’aide de l’objet [Text](/fr/fine-reader/engine/api-reference/text-related-objects/text), accessible via les propriétés des blocs de texte, de tableau ou de code-barres.

  Les données importantes que vous avez trouvées peuvent être enregistrées ou traitées selon vos besoins. Veuillez consulter [Optimisation supplémentaire pour des tâches spécifiques](/fr/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation/text-extraction#optimization) ci-dessous pour plus d’informations.
</Accordion>

<Accordion title="(Facultatif) Étape 6. Exportation du document">
  Vous pouvez également stocker le texte extrait dans un format facilement exploitable, tel que TXT, ou dans un format structuré qui vous permettra de retrouver facilement les informations nécessaires par la suite, tel que JSON.

  Utilisez 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) avec la constante [FileExportFormatEnum](/fr/fine-reader/engine/api-reference/enumerations/fileexportformatenum) appropriée 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. Veuillez consulter [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.

  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}
  // Enregistrer le texte du document reconnu au format TXT
  frDocument.Export( "C:\\MyText.txt", FREngine.FileExportFormatEnum.FEF_TextUnicodeDefaults, null );
  // Libérer l’objet FRDocument
  frDocument.Close();
  ```

  ### C++ (COM)

  ```cpp theme={null}
  // Enregistrer le texte du document reconnu au format TXT
  frDocument->Export( L"C:\\MyText.txt", FREngine::FEF_TextUnicodeDefaults, 0 );
  // Libérer l’objet FRDocument
  frDocument->Close();
  ```
</Accordion>

<Accordion title="Étape 7. 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;
          // Supprimer 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 en toute sécurité la bibliothèque FREngine.dll
   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 une liste des fichiers nécessaires au fonctionnement de votre application. Pour le traitement selon 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

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 en [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>

* 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 des objets de paramètres d'analyse, de reconnaissance et de synthèse.

* [Reconnaître l'écriture manuscrite](/fr/fine-reader/engine/guided-tour/advanced-techniques/recognizing-handwritten-texts)<br />Les profils TextExtraction\_\*\*\* n'incluent pas la reconnaissance du texte manuscrit ou en lettres moulées. Si vous devez reconnaître l'écriture manuscrite, définissez la propriété [DetectHandwritten](/fr/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/pageanalysisparams#detecthandwritten) de l'objet [PageAnalysisParams](/fr/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/pageanalysisparams) sur TRUE.

* [Objet PageProcessingParams](/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, codes-barres, langue de reconnaissance, marge d'erreur de reconnaissance).

* [Objet SynthesisParamsForPage](/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 restauration de la mise en forme d'une page lors de la synthèse.

* [Objet SynthesisParamsForDocument](/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 : restauration de sa structure et de sa mise en forme.

* [Objet MultiProcessingParams](/fr/fine-reader/engine/api-reference/parameter-objects/multiprocessingparams) - Linux et Windows uniquement<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 et la reconnaissance, 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.

* Recherche d'informations importantes
  * [Utilisation de Layout et des blocs](/fr/fine-reader/engine/guided-tour/advanced-techniques/working-with-layout-and-blocks)<br />Présentation de la mise en page, des types de blocs et de leur utilisation.
  * [Objet Layout](/fr/fine-reader/engine/api-reference/layout-related-objects/layout)<br />Les paramètres de cet objet donnent accès à la mise en page et au texte reconnu après la reconnaissance du document.
  * [Utilisation du texte](/fr/fine-reader/engine/guided-tour/advanced-techniques/working-with-text)<br />Utilisation du texte reconnu, des paragraphes, des mots et des symboles.

* Nouvelle lecture du document à l'aide de paramètres spéciaux pour le type de données spécifié
  * [Reconnaissance au niveau du champ](/fr/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation/field-level-recognition)<br />Description du scénario de reconnaissance de courts segments de texte.

* Enregistrement des données
  * Pour enregistrer les données reconnues, vous pouvez utiliser les méthodes [Export](/fr/fine-reader/engine/api-reference/document-related-objects/frdocument/export-method) ou [ExportPages](/fr/fine-reader/engine/api-reference/document-related-objects/frdocument/exportpages-method) de l'objet [FRDocument](/fr/fine-reader/engine/api-reference/document-related-objects/frdocument) en attribuant la constante [FileExportFormatEnum](/fr/fine-reader/engine/api-reference/enumerations/fileexportformatenum) comme l'un des paramètres.
  * [Archivage de documents](/fr/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation/document-archiving)<br />Description du scénario d'enregistrement d'une copie électronique du document.

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