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

# Document Comparison

> Comparez un document papier ou son image à une copie avec l’API de comparaison de documents d’ABBYY FineReader Engine — détectez les insertions, suppressions ou modifications de texte.

Lorsque vous travaillez avec des documents papier, vous devez repérer et corriger les erreurs ou les modifications apportées intentionnellement. Utilisez l’API Document Comparison pour rechercher ces modifications rapidement et efficacement.

Ce scénario permet de comparer des documents particulièrement importants, tels que des contrats et des documents bancaires, avec leurs copies. Le résultat de la comparaison contient des informations sur les différences de type de contenu (texte uniquement), de type de modification (supprimé, inséré ou modifié) et sur leur emplacement dans l’original et dans la copie. Vous pouvez obtenir la liste des différences détectées ou la région de n’importe quelle modification, puis enregistrer le résultat de la comparaison dans un fichier externe pour un traitement ultérieur ou un stockage à long terme.

Pour comparer des documents ou des pages, les fichiers obtenus par numérisation ou enregistrés au format électronique passent généralement par plusieurs étapes de traitement, chacune présentant ses propres particularités :

1. Prétraitement des fichiers numérisés ou des images

Les fichiers et leurs copies nécessitent un certain prétraitement avant la reconnaissance s’ils comportent des défauts ou des annotations ajoutées intentionnellement, telles que des signatures ou des tampons.

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.) du document sont identifiés. Au cours de la synthèse du document, la structure logique du document est restaurée, tandis que la synthèse de la page permet de restituer entièrement la mise en forme du document (polices, styles, etc.)

3. Comparaison des documents ou des pages

Pour comparer des documents ou des pages avec leurs copies, utilisez les fichiers reconnus à l’aide d’ABBYY FineReader Engine. Vous pouvez utiliser les deux versions d’un document dans des formats différents. Après la comparaison, vous obtenez un résultat contenant la liste des modifications ; utilisez-le pour récupérer les informations sur l’emplacement des modifications. Si vous utilisez une vérification manuelle, servez-vous de ces informations pour mettre en évidence les modifications dans le texte, afin de faciliter le travail de l’opérateur.

4. Exportation vers un format externe

Vous pouvez également enregistrer le résultat de la comparaison aux formats XML et DOCX.

La procédure décrite ci-dessous est également illustrée par l’exemple [Document Comparison](/fr/fine-reader/engine/guided-tour/samples#documentcomparison_linux) pour Linux et macOS, ainsi que par l’outil de démonstration Windows [Document Comparison](/fr/fine-reader/engine/guided-tour/samples#documentcomparison).

<div id="scenario-implementation">
  ## Implémentation 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 dans ce scénario.

<Accordion title="Étape 1. Chargement d’ABBYY FineReader Engine">
  Pour commencer à travailler avec 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 racine de la hiérarchie des objets d’ABBYY FineReader Engine et fournit différents 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 [d’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 = "";
          // Charger la bibliothèque FREngine.dll
          dllHandle = LoadLibraryEx(enginePath, IntPtr.Zero, LOAD_WITH_ALTERED_SEARCH_PATH);
             
          try
          {
              if (dllHandle == IntPtr.Zero)
              {
                  throw new Exception("Can't load " + enginePath);
              }
              IntPtr initializeEnginePtr = GetProcAddress(dllHandle, "InitializeEngine");
              if (initializeEnginePtr == IntPtr.Zero)
              {
                  throw new Exception("Can't find InitializeEngine function");
              }
              IntPtr deinitializeEnginePtr = GetProcAddress(dllHandle, "DeinitializeEngine");
              if (deinitializeEnginePtr == IntPtr.Zero)
              {
                  throw new Exception("Can't find DeinitializeEngine function");
              }
              IntPtr dllCanUnloadNowPtr = GetProcAddress(dllHandle, "DllCanUnloadNow");
              if (dllCanUnloadNowPtr == IntPtr.Zero)
              {
                  throw new Exception("Can't find DllCanUnloadNow function");
              }
              // Convertir les 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));
              // Appeler la fonction InitializeEngine 
              // en passant 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érer 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 de FREngine.dll
      private IntPtr dllHandle = IntPtr.Zero;
      private InitializeEngine initializeEngine = null;
      private DeinitializeEngine deinitializeEngine = null;
      private DllCanUnloadNow dllCanUnloadNow = null;
  }
  ```
</Accordion>

<Accordion title="Étape 2. Chargement et prétraitement des fichiers et 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 et les colonnes d’origine, les polices, les styles, etc. Utilisez l’objet [FRPage](/fr/fine-reader/engine/api-reference/document-related-objects/frpage) si vous souhaitez comparer des pages.

  Pour charger les images d’un même 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é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 à 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éez l’objet FRDocument à partir d’un fichier image
  FREngine.IFRDocument frDocument = engine.CreateFRDocumentFromImage( "C:\\MyImage.tif", null );
  ```
</Accordion>

<Accordion title="Étape 3. 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 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).<br />Vous pouvez définir les paramètres de reconnaissance de vos documents en chargeant un profil prédéfini approprié (consultez [Working with Profiles](/fr/fine-reader/engine/guided-tour/advanced-techniques/working-with-profiles) pour plus d’informations).

  ### C\#

  ```csharp theme={null}
  // Traitez le document avec les paramètres par défaut
  // Vous pouvez les modifier si nécessaire, par exemple en chargeant un profil au préalable
  frDocument.Process( null );
  ```
</Accordion>

<Accordion title="Étape 4. Comparaison des documents ou des pages">
  Pour comparer les documents ou les pages à leurs copies :

  1. Assurez-vous que votre licence ABBYY FineReader Engine prend en charge le module [Compare Documents](/fr/fine-reader/engine/licensing/modules#comparedocuments).
  2. Créez un objet [Comparator](/fr/fine-reader/engine/api-reference/document-comparison-objects/comparator) à l’aide de la méthode [CreateComparator](/fr/fine-reader/engine/api-reference/engine-object-iengine-interface/creation-methods/createlessobjectgreater-methods) de l’objet [Engine](/fr/fine-reader/engine/api-reference/engine-object-iengine-interface).
  3. \[facultatif] Utilisez l’objet [ComparisonParams](/fr/fine-reader/engine/api-reference/document-comparison-objects/comparisonparams) pour définir les propriétés selon les valeurs souhaitées.
  4. Appelez la méthode [CompareDocuments](/fr/fine-reader/engine/api-reference/document-comparison-objects/comparator/comparedocuments-method) de l’objet [Comparator](/fr/fine-reader/engine/api-reference/document-comparison-objects/comparator) pour comparer le document original à sa copie. Vous recevrez un objet [ComparisonResult](/fr/fine-reader/engine/api-reference/document-comparison-objects/comparisonresult) contenant des informations sur les modifications détectées.

  ### C\#

  ```csharp theme={null}
  // Effectuer la comparaison des documents 
  FREngine.IComparator comparator = engine.CreateComparator();
  FREngine.IComparisonResult comparatorResult = 
      comparator.CompareDocuments( referenceFRDocument, userFRDocument, null, null );
  ```
</Accordion>

<Accordion title="Étape 5. Exploitation des modifications détectées">
  L’objet [ComparisonResult](/fr/fine-reader/engine/api-reference/document-comparison-objects/comparisonresult) contient la liste complète des différences et fournit des méthodes permettant d’obtenir les différences pour des pages individuelles. Vous pouvez accéder aux modifications du document original et de sa copie à l’aide des méthodes [GetChangesForReferencePage](/fr/fine-reader/engine/api-reference/document-comparison-objects/comparisonresult/getchangesforreferencepage-method) et [GetChangesForUserPage](/fr/fine-reader/engine/api-reference/document-comparison-objects/comparisonresult/getchangesforuserpage-method). Utilisez l’objet [ChangeLocation](/fr/fine-reader/engine/api-reference/document-comparison-objects/changelocation) pour obtenir des informations sur l’emplacement de la modification, ainsi que sa propriété [RegionForPage](/fr/fine-reader/engine/api-reference/document-comparison-objects/changelocation/regionforpage-property) pour obtenir la région de la modification sur la page spécifiée.

  ### C\#

  ```csharp theme={null}
  // Obtenir les informations sur la modification détectée et son emplacement dans le document original
  FREngine.IChanges changes = comparatorResult.Changes;
  foreach( FREngine.IChange change in changes ) {
        FREngine.ModificationTypeEnum modificationType = change.ModificationType;
        FREngine.IChangeLocation referenceLocation = change.ReferenceLocation;
        // Vous pouvez maintenant mettre ces modifications en surbrillance sur la page pour qu’un opérateur les vérifie
        ... 
  }
  ```
</Accordion>

<Accordion title="Étape 6. Exportation du résultat de la comparaison">
  Pour exporter le résultat de la comparaison, appelez la méthode [Export](/fr/fine-reader/engine/api-reference/document-comparison-objects/comparisonresult/export-method) de l’objet [ComparisonResult](/fr/fine-reader/engine/api-reference/document-comparison-objects/comparisonresult) et transmettez le chemin d’accès du fichier comme paramètre d’entrée. Les données peuvent être enregistrées dans un fichier XML ou DOCX avec suivi des modifications.

  C#

  ```csharp theme={null}
  // Enregistrer au format XML
  comparisonResult.Export( "C:\\ComparisonResult.xml", FREngine.ComparatorExportFormatEnum.CEF_Xml, null );
  ```
</Accordion>

<Accordion title="Étape 7. Déchargement d’ABBYY FineReader Engine">
  Une fois que vous avez fini 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;
  }
  ```
</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 générer automatiquement une liste des fichiers nécessaires au fonctionnement de votre application. Pour le traitement dans 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 en [langues CJK](/fr/fine-reader/engine/guided-tour/advanced-techniques/recognizing-cjk-languages#cjk)). Consultez [Utilisation du fichier FREngineDistribution.csv](/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">
  ## Optimisations supplémentaires 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 du traitement :

* 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.
  * [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 permettant de restaurer 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 sous 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 séquentiel) 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.

<div id="see-also">
  ## Voir aussi
</div>

[Implémentation de scénarios d’utilisation de base](/fr/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation)