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

# Dokumentenvergleich

> Vergleichen Sie ein Papierdokument oder sein Bild mit einer Kopie mithilfe der ABBYY FineReader Engine Document Comparison API — erkennen Sie eingefügte, gelöschte oder geänderte Textunterschiede.

Bei der Arbeit mit Papierdokumenten müssen Fehler oder absichtlich vorgenommene Änderungen erkannt und korrigiert werden. Verwenden Sie die Document Comparison API, um solche Änderungen schnell und effizient zu finden.

Dieses Szenario wird verwendet, um besonders wichtige Dokumente wie Verträge und Bankunterlagen mit ihren Kopien zu vergleichen. Das Vergleichsergebnis enthält Informationen über Unterschiede im Inhaltstyp (nur Text), die Art der Änderung (gelöscht, eingefügt oder geändert) sowie deren Positionen im Original und in der Kopie. Sie können die Liste der erkannten Unterschiede oder die Region einer beliebigen Änderung abrufen und das Vergleichsergebnis zur weiteren Verarbeitung oder langfristigen Speicherung in einer externen Datei speichern.

Um Dokumente oder Seiten zu vergleichen, durchlaufen durch Scannen erfasste oder in einem elektronischen Format gespeicherte Dateien in der Regel mehrere Verarbeitungsschritte, von denen jeder seine eigenen Besonderheiten aufweist:

1. Vorverarbeitung gescannter Dateien oder Bilder

Die Dateien und ihre Kopien müssen vor der Erkennung vorverarbeitet werden, wenn sie Mängel oder absichtlich angebrachte Vermerke wie Unterschriften oder Stempel enthalten.

2. Erkennung mit vollständiger Wiederherstellung der Dokumentstruktur und Formatierung

Bei der Erkennung eines Dokuments werden verschiedene Layoutelemente des Dokuments identifiziert (Text, Tabellen, Bilder, Separatoren usw.). Im Verlauf der Dokumentsynthese wird die logische Struktur des Dokuments wiederhergestellt, während die Seitensynthese eine vollständige Wiederherstellung der Dokumentformatierung (Schriftarten, Stile usw.) ermöglicht.

3. Vergleich von Dokumenten oder Seiten

Um Dokumente oder Seiten mit ihren Kopien zu vergleichen, verwenden Sie Dateien, die mit ABBYY FineReader Engine erkannt wurden. Dabei können Sie zwei Versionen eines Dokuments in unterschiedlichen Formaten verwenden. Nach dem Vergleich erhalten Sie ein Ergebnis mit einer Liste der Änderungen, anhand derer Sie Informationen über deren Position abrufen können. Wenn Sie eine manuelle Verifizierung verwenden, können Sie diese Informationen nutzen, um Änderungen im Text hervorzuheben und so dem Operator die Arbeit zu erleichtern.

4. Export in ein externes Format

Sie können das Vergleichsergebnis auch im XML- und DOCX-Format speichern.

Das unten beschriebene Verfahren wird auch durch das [Dokumentenvergleich](/de/fine-reader/engine/guided-tour/samples#documentcomparison_linux)-Beispiel für Linux und macOS sowie durch das Windows-Demotool [Dokumentenvergleich](/de/fine-reader/engine/guided-tour/samples#documentcomparison) veranschaulicht.

<div id="scenario-implementation">
  ## Implementierung des Szenarios
</div>

<Note>
  Die in diesem Thema bereitgestellten Codebeispiele sind Windows-spezifisch.
</Note>

Nachfolgend finden Sie eine detaillierte Beschreibung der empfohlenen Methode zur Verwendung von ABBYY FineReader Engine in diesem Szenario.

<Accordion title="Schritt 1. Laden von ABBYY FineReader Engine">
  Um mit ABBYY FineReader Engine zu arbeiten, müssen Sie das Objekt [Engine](/de/fine-reader/engine/api-reference/engine-object-iengine-interface) erstellen. Das Engine-Objekt ist das oberste Objekt in der Hierarchie der ABBYY FineReader Engine-Objekte und stellt verschiedene globale Einstellungen, einige Verarbeitungsmethoden sowie Methoden zum Erstellen anderer Objekte bereit.

  Zum Erstellen des Engine-Objekts können Sie die Funktion [InitializeEngine](/de/fine-reader/engine/api-reference/functions/initializeengine-function) verwenden. Siehe auch [weitere Möglichkeiten zum Laden des Engine-Objekts](/de/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()
      {
          // Initialisieren Sie diese Variablen mit dem vollständigen Pfad zu FREngine.dll, Ihrer Customer Project ID,
          // und, falls zutreffend, mit dem Pfad zu Ihrer Online License-Token-Datei und dem Passwort für die Online License
          string enginePath = "";
          string customerProjectId = "";
          string licensePath = "";
          string licensePassword = "";
          // Die Bibliothek FREngine.dll laden
          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");
              }
              // Zeiger in Delegaten konvertieren
              initializeEngine = (InitializeEngine)Marshal.GetDelegateForFunctionPointer(
                  initializeEnginePtr, typeof(InitializeEngine));
              deinitializeEngine = (DeinitializeEngine)Marshal.GetDelegateForFunctionPointer(
                  deinitializeEnginePtr, typeof(DeinitializeEngine));
              dllCanUnloadNow = (DllCanUnloadNow)Marshal.GetDelegateForFunctionPointer(
                  dllCanUnloadNowPtr, typeof(DllCanUnloadNow));
              // Die Funktion InitializeEngine aufrufen 
              // und den Pfad zur Online License-Datei sowie das Passwort für die Online License übergeben
              int hresult = initializeEngine(customerProjectId, licensePath, licensePassword, 
                  "", "", false, ref engine);
              Marshal.ThrowExceptionForHR(hresult);
          }
          catch (Exception)
          {
              // Die Bibliothek FREngine.dll freigeben
              engine = null;
              // Alle Objekte vor dem Aufruf von FreeLibrary löschen
              GC.Collect();
              GC.WaitForPendingFinalizers();
              GC.Collect();
              FreeLibrary(dllHandle);
              dllHandle = IntPtr.Zero;
              initializeEngine = null;
              deinitializeEngine = null;
              dllCanUnloadNow = null;
              throw;
          }
      }
      // Funktionen aus 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);
      // Funktionen aus 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();
      // Private Variablen
      private FREngine.IEngine engine = null;
      // Handle für FREngine.dll
      private IntPtr dllHandle = IntPtr.Zero;
      private InitializeEngine initializeEngine = null;
      private DeinitializeEngine deinitializeEngine = null;
      private DllCanUnloadNow dllCanUnloadNow = null;
  }
  ```
</Accordion>

<Accordion title="Schritt 2. Laden und Vorverarbeiten von Dateien und Bildern">
  ABBYY FineReader Engine stellt das [FRDocument](/de/fine-reader/engine/api-reference/document-related-objects/frdocument)-Objekt bereit, mit dem mehrseitige Dokumente verarbeitet werden können. Mit diesem Objekt können Sie die logische Struktur des Dokuments beibehalten und den ursprünglichen Text sowie Spalten, Schriftarten, Stile usw. erhalten. Verwenden Sie das [FRPage](/de/fine-reader/engine/api-reference/document-related-objects/frpage)-Objekt, wenn Sie Seiten miteinander vergleichen möchten.

  Um Bilder eines einzelnen Dokuments zu laden und vorzuverarbeiten, sollten Sie das FRDocument-Objekt erstellen und ihm Bilder hinzufügen. Dazu haben Sie folgende Möglichkeiten:

  * Erstellen Sie das FRDocument-Objekt mit der [CreateFRDocumentFromImage](/de/fine-reader/engine/api-reference/engine-object-iengine-interface/creation-methods/createfrdocumentfromimage-method)-Methode des Engine-Objekts. Diese Methode erstellt das FRDocument-Objekt und lädt Bilder aus der angegebenen Datei.
  * Erstellen Sie das FRDocument-Objekt mithilfe der [CreateFRDocument](/de/fine-reader/engine/api-reference/engine-object-iengine-interface/creation-methods/createlessobjectgreater-methods)-Methode des Engine-Objekts und fügen Sie dann dem erstellten FRDocument-Objekt Bilder aus einer Datei hinzu (verwenden Sie dazu die [AddImageFile](/de/fine-reader/engine/api-reference/document-related-objects/frdocument/addimagefile-method)-, [AddImageFileWithPassword](/de/fine-reader/engine/api-reference/document-related-objects/frdocument/addimagefilewithpassword-method)- oder [AddImageFileWithPasswordCallback](/de/fine-reader/engine/api-reference/document-related-objects/frdocument/addimagefilewithpasswordcallback-method)-Methode des FRDocument-Objekts).

  ### C\#

  ```csharp theme={null}
  // Erstellen Sie das FRDocument-Objekt aus einer Bilddatei
  FREngine.IFRDocument frDocument = engine.CreateFRDocumentFromImage( "C:\\MyImage.tif", null );
  ```
</Accordion>

<Accordion title="Schritt 3. Dokumenterkennung">
  Um ein Dokument zu erkennen, empfehlen wir die Analyse- und Erkennungsmethoden des FRDocument-Objekts. Dieses Objekt bietet eine ganze Reihe von Methoden für Dokumentanalyse, Erkennung und Synthese. Die komfortabelste Methode, die Dokumentanalyse, Erkennung und Synthese in einem Schritt bereitstellt, ist die [Process](/de/fine-reader/engine/api-reference/document-related-objects/frdocument/process-method)-Methode. Außerdem nutzt sie die Möglichkeiten zur gleichzeitigen Verarbeitung auf Multiprozessor- und Multicore-Systemen besonders effizient. Sie können die aufeinanderfolgenden Schritte Vorverarbeitung, Analyse, Erkennung und Synthese jedoch auch mit den Methoden [Preprocess](/de/fine-reader/engine/api-reference/document-related-objects/frdocument/preprocess-method), [Analyze](/de/fine-reader/engine/api-reference/document-related-objects/frdocument/analyze-method), [Recognize](/de/fine-reader/engine/api-reference/document-related-objects/frdocument/recognize-method) und [Synthesize](/de/fine-reader/engine/api-reference/document-related-objects/frdocument/synthesize-method) ausführen.<br />Sie können die Erkennungsparameter für Ihre Dokumente festlegen, indem Sie ein geeignetes vordefiniertes Profil laden (weitere Informationen finden Sie unter [Arbeiten mit Profilen](/de/fine-reader/engine/guided-tour/advanced-techniques/working-with-profiles)).

  ### C\#

  ```csharp theme={null}
  // Verarbeiten Sie das Dokument mit den Standardparametern
  // Sie können diese bei Bedarf ändern, indem Sie beispielsweise vorher ein Profil laden
  frDocument.Process( null );
  ```
</Accordion>

<Accordion title="Schritt 4. Vergleichen von Dokumenten oder Seiten">
  So vergleichen Sie Dokumente oder Seiten mit ihren Kopien:

  1. Stellen Sie sicher, dass Ihre ABBYY FineReader Engine-Lizenz das Modul [Compare Documents](/de/fine-reader/engine/licensing/modules#comparedocuments) unterstützt.
  2. Erstellen Sie mithilfe der Methode [CreateComparator](/de/fine-reader/engine/api-reference/engine-object-iengine-interface/creation-methods/createlessobjectgreater-methods) des [Engine](/de/fine-reader/engine/api-reference/engine-object-iengine-interface)-Objekts ein Objekt vom Typ [Comparator](/de/fine-reader/engine/api-reference/document-comparison-objects/comparator).
  3. \[optional] Verwenden Sie das Objekt [ComparisonParams](/de/fine-reader/engine/api-reference/document-comparison-objects/comparisonparams), um die Eigenschaften auf die gewünschten Werte festzulegen.
  4. Rufen Sie die Methode [CompareDocuments](/de/fine-reader/engine/api-reference/document-comparison-objects/comparator/comparedocuments-method) des Objekts [Comparator](/de/fine-reader/engine/api-reference/document-comparison-objects/comparator) auf, um das Originaldokument mit der Kopie zu vergleichen. Sie erhalten ein Objekt vom Typ [ComparisonResult](/de/fine-reader/engine/api-reference/document-comparison-objects/comparisonresult), das Informationen zu den erkannten Änderungen enthält.

  ### C\#

  ```csharp theme={null}
  // Den Dokumentvergleich durchführen 
  FREngine.IComparator comparator = engine.CreateComparator();
  FREngine.IComparisonResult comparatorResult = 
      comparator.CompareDocuments( referenceFRDocument, userFRDocument, null, null );
  ```
</Accordion>

<Accordion title="Schritt 5. Arbeiten mit den erkannten Änderungen">
  Das Objekt [ComparisonResult](/de/fine-reader/engine/api-reference/document-comparison-objects/comparisonresult) enthält die vollständige Liste der Unterschiede und stellt Methoden bereit, mit denen Sie die Unterschiede für einzelne Seiten abrufen können. Sie können mit den Methoden [GetChangesForReferencePage](/de/fine-reader/engine/api-reference/document-comparison-objects/comparisonresult/getchangesforreferencepage-method) und [GetChangesForUserPage](/de/fine-reader/engine/api-reference/document-comparison-objects/comparisonresult/getchangesforuserpage-method) auf die Änderungen im Originaldokument und in seiner Kopie zugreifen. Verwenden Sie das Objekt [ChangeLocation](/de/fine-reader/engine/api-reference/document-comparison-objects/changelocation), um Informationen über die Position der Änderung abzurufen, und die Eigenschaft [RegionForPage](/de/fine-reader/engine/api-reference/document-comparison-objects/changelocation/regionforpage-property), um die Region der Änderung auf der angegebenen Seite zu erhalten.

  ### C\#

  ```csharp theme={null}
  // Informationen über die erkannte Änderung und ihre Position im Originaldokument abrufen
  FREngine.IChanges changes = comparatorResult.Changes;
  foreach( FREngine.IChange change in changes ) {
        FREngine.ModificationTypeEnum modificationType = change.ModificationType;
        FREngine.IChangeLocation referenceLocation = change.ReferenceLocation;
        // Jetzt können Sie diese Änderungen auf der Seite hervorheben, damit sie von einem Benutzer überprüft werden können
        ... 
  }
  ```
</Accordion>

<Accordion title="Schritt 6. Exportieren des Vergleichsergebnisses">
  Um das Vergleichsergebnis zu exportieren, rufen Sie die Methode [Export](/de/fine-reader/engine/api-reference/document-comparison-objects/comparisonresult/export-method) des Objekts [ComparisonResult](/de/fine-reader/engine/api-reference/document-comparison-objects/comparisonresult) auf und übergeben den Pfad zur Datei als Eingabeparameter. Die Daten können als XML-Datei oder als DOCX-Datei mit nachverfolgten Änderungen gespeichert werden.

  C#

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

<Accordion title="Schritt 7. ABBYY FineReader Engine entladen">
  Nachdem Sie die Arbeit mit ABBYY FineReader Engine abgeschlossen haben, müssen Sie das [Engine](/de/fine-reader/engine/api-reference/engine-object-iengine-interface)-Objekt entladen. Verwenden Sie dazu die exportierte Funktion [DeinitializeEngine](/de/fine-reader/engine/api-reference/functions/deinitializeengine-function).

  ### C\#

  ```csharp theme={null}
  public class EngineLoader : IDisposable
  {
      // FineReader Engine entladen
      public void Dispose()
      {
          if (engine == null)
          {
              // Engine wurde nicht geladen
              return;
          }
          engine = null;
          // Alle Objekte vor dem Aufruf von FreeLibrary freigeben
          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;
          // Ausnahme nach dem Bereinigen auslösen
          Marshal.ThrowExceptionForHR(hresult);
      }
      // Funktionen aus 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);
      // Funktionen aus 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();
      // private Variablen
      private FREngine.IEngine engine = null;
      // Handle für FREngine.dll
      private IntPtr dllHandle = IntPtr.Zero;
      private InitializeEngine initializeEngine = null;
      private DeinitializeEngine deinitializeEngine = null;
      private DllCanUnloadNow dllCanUnloadNow = null;
  }
  ```
</Accordion>

<div id="required-resources">
  ## Erforderliche Ressourcen
</div>

Sie können die Datei [FREngineDistribution.csv](/de/fine-reader/engine/distribution/distribution-windows/distribution-kit/working-with-the-frenginedistributioncsv-file) verwenden, um automatisch eine Liste der Dateien zu erstellen, die erforderlich sind, damit Ihre Anwendung funktioniert. Wählen Sie für die Verarbeitung in diesem Szenario in Spalte 5 (RequiredByModule) die folgenden Werte aus:

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

Wenn Sie das Standardszenario ändern, passen Sie die erforderlichen Module entsprechend an. Außerdem müssen Sie die Oberflächensprachen, Erkennungssprachen und alle zusätzlichen Funktionen angeben, die Ihre Anwendung verwendet (z. B. Opening.PDF, wenn Sie PDF-Dateien öffnen müssen, oder Processing.OCR.CJK, wenn Sie Texte in [CJK-Sprachen](/de/fine-reader/engine/guided-tour/advanced-techniques/recognizing-cjk-languages#cjk) erkennen müssen). Weitere Informationen finden Sie unter [Arbeiten mit der Datei FREngineDistribution.csv](/de/fine-reader/engine/distribution/distribution-windows/distribution-kit/working-with-the-frenginedistributioncsv-file).

<div id="additional-optimization-for-specific-tasks">
  ## Zusätzliche Optimierung für bestimmte Aufgaben
</div>

Nachfolgend finden Sie eine Übersicht der Hilfethemen mit zusätzlichen Informationen zur Anpassung von Einstellungen in verschiedenen Verarbeitungsphasen:

* Scannen – nur unter Windows
  * [Scannen](/de/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation/scanning)<br />Beschreibung des ABBYY FineReader Engine-Szenarios zum Scannen von Dokumenten.
* Erkennung
  * [Anpassen von Parametern für Vorverarbeitung, Analyse, Erkennung und Synthese](/de/fine-reader/engine/guided-tour/advanced-techniques/tuning-parameters-of-preprocessing-analysis-recognition-and-synthesis)<br />Anpassung der Dokumentverarbeitung mithilfe von Parameterobjekten für Analyse, Erkennung und Synthese.
  * [PageProcessingParams-Objekt](/de/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/pageprocessingparams)<br />Dieses Objekt ermöglicht die Anpassung von Analyse- und Erkennungsparametern. Mit diesem Objekt können Sie angeben, welche Bild- und Texteigenschaften erkannt werden sollen (invertiertes Bild, Ausrichtung, Barcodes, Erkennungssprache, zulässige Fehlermarge bei der Erkennung).
  * [SynthesisParamsForPage-Objekt](/de/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/synthesisparamsforpage)<br />Dieses Objekt enthält Parameter, die für die Wiederherstellung der Seitenformatierung während der Synthese verantwortlich sind.
  * [SynthesisParamsForDocument-Objekt](/de/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/synthesisparamsfordocument)<br />Dieses Objekt ermöglicht die Anpassung der Dokumentsynthese: die Wiederherstellung der Struktur und Formatierung des Dokuments.
  * [MultiProcessingParams-Objekt](/de/fine-reader/engine/api-reference/parameter-objects/multiprocessingparams) - Für Linux und Windows implementiert<br />Die gleichzeitige Verarbeitung kann beim Verarbeiten einer großen Anzahl von Bildern nützlich sein. In diesem Fall wird die Verarbeitungslast beim Öffnen und Vorverarbeiten von Bildern, bei der Layout-Analyse, bei der Erkennung und beim Export auf die Prozessorkerne verteilt, wodurch die Verarbeitung beschleunigt werden kann.<br />Die Verarbeitungsmodi (gleichzeitig oder nacheinander) werden mit der Eigenschaft MultiProcessingMode festgelegt. Die Eigenschaft RecognitionProcessesCount steuert die Anzahl der Prozesse, die gestartet werden können.

<div id="see-also">
  ## Siehe auch
</div>

[Implementierung grundlegender Anwendungsszenarien](/de/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation)