Dokumentenvergleich - ABBYY Documentation

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:

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.

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.

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.

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-Beispiel für Linux und macOS sowie durch das Windows-Demotool Dokumentenvergleich veranschaulicht.

Implementierung des Szenarios

Die in diesem Thema bereitgestellten Codebeispiele sind Windows-spezifisch.

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

Schritt 1. Laden von ABBYY FineReader Engine

Um mit ABBYY FineReader Engine zu arbeiten, müssen Sie das Objekt Engine 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 verwenden. Siehe auch weitere Möglichkeiten zum Laden des Engine-Objekts (Win).

C#

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

Schritt 2. Laden und Vorverarbeiten von Dateien und Bildern

ABBYY FineReader Engine stellt das 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-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-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-Methode des Engine-Objekts und fügen Sie dann dem erstellten FRDocument-Objekt Bilder aus einer Datei hinzu (verwenden Sie dazu die AddImageFile-, AddImageFileWithPassword- oder AddImageFileWithPasswordCallback-Methode des FRDocument-Objekts).

C#

// Erstellen Sie das FRDocument-Objekt aus einer Bilddatei
FREngine.IFRDocument frDocument = engine.CreateFRDocumentFromImage( "C:\\MyImage.tif", null );

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-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, Analyze, Recognize und Synthesize ausführen.
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).

C#

// Verarbeiten Sie das Dokument mit den Standardparametern
// Sie können diese bei Bedarf ändern, indem Sie beispielsweise vorher ein Profil laden
frDocument.Process( null );

Schritt 4. Vergleichen von Dokumenten oder Seiten

So vergleichen Sie Dokumente oder Seiten mit ihren Kopien:

Stellen Sie sicher, dass Ihre ABBYY FineReader Engine-Lizenz das Modul Compare Documents unterstützt.
Erstellen Sie mithilfe der Methode CreateComparator des Engine-Objekts ein Objekt vom Typ Comparator.
[optional] Verwenden Sie das Objekt ComparisonParams, um die Eigenschaften auf die gewünschten Werte festzulegen.
Rufen Sie die Methode CompareDocuments des Objekts Comparator auf, um das Originaldokument mit der Kopie zu vergleichen. Sie erhalten ein Objekt vom Typ ComparisonResult, das Informationen zu den erkannten Änderungen enthält.

C#

// Den Dokumentvergleich durchführen 
FREngine.IComparator comparator = engine.CreateComparator();
FREngine.IComparisonResult comparatorResult = 
    comparator.CompareDocuments( referenceFRDocument, userFRDocument, null, null );

Schritt 5. Arbeiten mit den erkannten Änderungen

Das Objekt 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 und GetChangesForUserPage auf die Änderungen im Originaldokument und in seiner Kopie zugreifen. Verwenden Sie das Objekt ChangeLocation, um Informationen über die Position der Änderung abzurufen, und die Eigenschaft RegionForPage, um die Region der Änderung auf der angegebenen Seite zu erhalten.

C#

// 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
      ... 
}

Schritt 6. Exportieren des Vergleichsergebnisses

Um das Vergleichsergebnis zu exportieren, rufen Sie die Methode Export des Objekts 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#

// Im XML-Format speichern
comparisonResult.Export( "C:\\ComparisonResult.xml", FREngine.ComparatorExportFormatEnum.CEF_Xml, null );

Schritt 7. ABBYY FineReader Engine entladen

Nachdem Sie die Arbeit mit ABBYY FineReader Engine abgeschlossen haben, müssen Sie das Engine-Objekt entladen. Verwenden Sie dazu die exportierte Funktion DeinitializeEngine.

C#

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

Erforderliche Ressourcen

Sie können die Datei FREngineDistribution.csv 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 erkennen müssen). Weitere Informationen finden Sie unter Arbeiten mit der Datei FREngineDistribution.csv.

Zusätzliche Optimierung für bestimmte Aufgaben

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

Scannen – nur unter Windows
- Scannen
  Beschreibung des ABBYY FineReader Engine-Szenarios zum Scannen von Dokumenten.
Erkennung
- Anpassen von Parametern für Vorverarbeitung, Analyse, Erkennung und Synthese
  Anpassung der Dokumentverarbeitung mithilfe von Parameterobjekten für Analyse, Erkennung und Synthese.
- PageProcessingParams-Objekt
  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
  Dieses Objekt enthält Parameter, die für die Wiederherstellung der Seitenformatierung während der Synthese verantwortlich sind.
- SynthesisParamsForDocument-Objekt
  Dieses Objekt ermöglicht die Anpassung der Dokumentsynthese: die Wiederherstellung der Struktur und Formatierung des Dokuments.
- MultiProcessingParams-Objekt - Für Linux und Windows implementiert
  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.
  Die Verarbeitungsmodi (gleichzeitig oder nacheinander) werden mit der Eigenschaft MultiProcessingMode festgelegt. Die Eigenschaft RecognitionProcessesCount steuert die Anzahl der Prozesse, die gestartet werden können.

Siehe auch

Implementierung grundlegender Anwendungsszenarien

​Implementierung des Szenarios

​C#

​C#

​C#

​C#

​C#

​C#

​Erforderliche Ressourcen

​Zusätzliche Optimierung für bestimmte Aufgaben

​Siehe auch

Implementierung des Szenarios

C#

C#

C#

C#

C#

C#

Erforderliche Ressourcen

Zusätzliche Optimierung für bestimmte Aufgaben

Siehe auch