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

# Conversion de documents

> Convertissez des images de documents en formats éditables (RTF, DOCX, ODT) avec ABBYY FineReader Engine tout en préservant la mise en page d’origine, les polices, les tableaux et la structure du document.

Le résultat de ce scénario est une version modifiable d’un document.

Dans ce scénario, les images de documents sont reconnues tout en conservant intégralement la mise en forme d’origine, puis les données sont enregistrées dans un format de fichier modifiable. Vous obtenez ainsi des versions modifiables de vos documents, faciles à vérifier pour détecter d’éventuelles erreurs et à modifier. Vous pouvez également copier tout ou partie du texte pour le réutiliser.

Un document passe par plusieurs étapes de traitement, qui diffèrent à certains égards des autres scénarios courants :

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 optiquement. Par exemple, les images bruitées ou présentant des lignes de texte déformées nécessitent certaines corrections pour garantir la réussite de la reconnaissance optique.

2. Reconnaissance avec restauration complète de la structure et de la mise en forme du document

   Lors de la reconnaissance d’un document, divers éléments de mise en page (texte, tableaux, images, Separator, etc.) sont identifiés. Au cours de la synthèse du document, sa structure logique est restaurée, tandis que la synthèse de la page permet de restituer intégralement la mise en forme du document (polices, styles, etc.).

3. Exportation vers un format modifiable

   Le document reconnu est enregistré dans un format modifiable, tel que RTF ou DOCX.

<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 de convertir des documents. Cette méthode utilise 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). 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 : 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, à 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), l’ensemble des paramètres de traitement les mieux adaptés à ce scénario. Cette méthode prend le nom du profil en paramètre d’entrée. Veuillez consulter [Working with Profiles](/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>DocumentConversion\_Accuracy</em></p></td><td><p>Les paramètres ont été optimisés pour la précision :</p><ul><li>Qualité optimale. Active la détection du style de police et la synthèse complète de la structure logique d’un document.</li></ul></td></tr><tr><td><p><em>DocumentConversion\_Normal</em></p></td><td><p>Les paramètres ont été optimisés pour la vitesse de traitement :</p><ul><li>Qualité optimale. Active la détection du style de police et la synthèse complète de la structure logique d’un document.</li><li>L’orientation de l’image n’est pas corrigée.</li><li>Le processus d’analyse du document est accéléré.</li></ul></td></tr></tbody></table>

  ### C\#

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

  ### C++ (COM)

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

  Si vous souhaitez modifier les paramètres de traitement, utilisez les objets Parameter appropriés. Veuillez consulter [Additional optimization for specific tasks](/fr/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation/document-conversion#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, les colonnes, les polices, les styles, etc.

  Pour charger les images d’un document unique et les prétraiter, vous devez créer l’objet FRDocument et y ajouter des images. Vous pouvez procéder de l’une des façons 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 à l’objet FRDocument créé 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}
  // Créer l'objet FRDocument à partir d'un fichier image
  FREngine::IFRDocumentPtr frDocument = Engine->CreateFRDocumentFromImage( L"C:\\MyImage.tif", 0 );
  ```

  <Note>
    Le prétraitement des images avec le profil DocumentConversion\_Normal chargé n’inclut pas la détection de l’orientation. Si vous souhaitez que l’orientation de l’image soit détectée automatiquement, vous devrez configurer des paramètres supplémentaires et transmettre l’objet correspondant à la fonction de prétraitement. Veuillez consulter [Additional optimization for specific tasks](/fr/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation/document-conversion#optimization) ci-dessous pour plus d’informations.
  </Note>
</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 fournit 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 combine l'analyse, la reconnaissance et la synthèse du document en une seule opération, 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
  // 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
  // Aucun paramètre supplémentaire n'est nécessaire, 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. Pour plus d'informations, 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.

  Une fois le traitement de l'objet FRDocument terminé, 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 document reconnu dans un format modifiable (par exemple, RTF)
  frDocument.Export( "C:\\MyText.rtf", FREngine.FileExportFormatEnum.FEF_RTF, null );
  // Libérer l'objet FRDocument
  frDocument.Close();
  ```

  ### C++ (COM)

  ```cpp theme={null}
  // Enregistrer le document reconnu dans un format modifiable (par exemple, RTF)
  frDocument->Export( L"C:\\MyText.rtf", FREngine::FEF_RTF, 0 );
  // Libérer l'objet FRDocument
  frDocument->Close();
  ```
</Accordion>

<Accordion title="Étape 6. Déchargement d’ABBYY FineReader Engine">
  Après avoir terminé d’utiliser ABBYY FineReader Engine, vous devez décharger l’objet [Engine](/fr/fine-reader/engine/api-reference/engine-object-iengine-interface). Pour cela, 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";
   }
   // Il est maintenant possible de 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 une liste des fichiers nécessaires au fonctionnement de votre application. Pour traiter selon ce scénario, sélectionnez les valeurs suivantes dans la colonne 5 (RequiredByModule) :

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

Vous trouverez ci-dessous un aperçu des rubriques d’aide contenant des informations supplémentaires sur la personnalisation des paramètres aux différentes étapes de la conversion d’un document en 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
  * [Ajustement 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 DocumentConversion\_\*\*\* n’incluent pas la reconnaissance de texte manuscrit ou en lettres détachées. Si vous devez reconnaître de 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) - *Disponible 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
  * [Ajustement 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.
  * [Objet RTFExportParams](/fr/fine-reader/engine/api-reference/parameter-objects/export-parameters/rtfexportparams)<br />Cet objet permet de personnaliser les paramètres d’enregistrement au format RTF/DOCX/ODT.
  * [Objet HTMLExportParams](/fr/fine-reader/engine/api-reference/parameter-objects/export-parameters/htmlexportparams)<br />Cet objet permet de personnaliser l’exportation au format HTML.
  * [Objet PPTExportParams](/fr/fine-reader/engine/api-reference/parameter-objects/export-parameters/pptexportparams)<br />Objet permettant de personnaliser les paramètres d’enregistrement au format PPTX.

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