Dokumentkonvertierung

Das Ergebnis dieses Szenarios ist eine bearbeitbare Version eines Dokuments. In diesem Szenario werden Dokumentbilder erkannt, wobei die ursprüngliche Formatierung vollständig erhalten bleibt, und die Daten in einem bearbeitbaren Dateiformat gespeichert. Dadurch erhalten Sie bearbeitbare Versionen Ihrer Dokumente, die sich einfach auf Fehler prüfen und bearbeiten lassen. Außerdem können Sie den gesamten Text oder Teile davon zur Wiederverwendung kopieren. Ein Dokument durchläuft mehrere Verarbeitungsschritte, die sich in einigen Aspekten leicht von anderen gängigen Szenarien unterscheiden:

Vorverarbeitung von gescannten Bildern oder Fotos

Bilder, die Sie mit einem Scanner oder einer Digitalkamera erfassen, müssen vor der optischen Erkennung möglicherweise noch nachbearbeitet werden. So müssen beispielsweise verrauschte Bilder oder Bilder mit verzerrten Textzeilen korrigiert werden, damit die optische Erkennung erfolgreich durchgeführt werden kann.

Erkennung mit vollständiger Wiederherstellung von Dokumentstruktur und Formatierung

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

Export in ein bearbeitbares Format

Das erkannte Dokument wird in einem bearbeitbaren Format wie RTF oder DOCX gespeichert.

Umsetzung des Szenarios

Die in diesem Abschnitt bereitgestellten Codebeispiele sind spezifisch für Windows.

Nachfolgend finden Sie eine ausführliche Beschreibung der empfohlenen Vorgehensweise für die Dokumentkonvertierung mit ABBYY FineReader Engine 12. Dabei werden Verarbeitungseinstellungen verwendet, die sich für diesen Zweck am besten eignen.

Schritt 1. Laden der ABBYY FineReader Engine

Um mit ABBYY FineReader Engine zu arbeiten, müssen Sie zunächst das Engine-Objekt erstellen. Das Engine-Objekt ist das übergeordnete Objekt in der Hierarchie der ABBYY FineReader Engine-Objekte und bietet verschiedene globale Einstellungen, einige Verarbeitungsmethoden sowie Methoden zum Erstellen weiterer Objekte.Um das Engine-Objekt zu erstellen, können Sie die Funktion InitializeEngine verwenden. Siehe auch andere 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 ggf. dem Pfad zur Online-Lizenz-Tokendatei und dem Online-Lizenzpasswort
        string enginePath = "";
        string customerProjectId = "";
        string licensePath = "";
        string licensePassword = "";
        // FREngine.dll-Bibliothek laden
        dllHandle = LoadLibraryEx(enginePath, IntPtr.Zero, LOAD_WITH_ALTERED_SEARCH_PATH);
           
        try
        {
            if (dllHandle == IntPtr.Zero)
            {
                throw new Exception("Laden nicht möglich: " + enginePath);
            }
            IntPtr initializeEnginePtr = GetProcAddress(dllHandle, "InitializeEngine");
            if (initializeEnginePtr == IntPtr.Zero)
            {
                throw new Exception("Funktion InitializeEngine nicht gefunden");
            }
            IntPtr deinitializeEnginePtr = GetProcAddress(dllHandle, "DeinitializeEngine");
            if (deinitializeEnginePtr == IntPtr.Zero)
            {
                throw new Exception("Funktion DeinitializeEngine nicht gefunden");
            }
            IntPtr dllCanUnloadNowPtr = GetProcAddress(dllHandle, "DllCanUnloadNow");
            if (dllCanUnloadNowPtr == IntPtr.Zero)
            {
                throw new Exception("Funktion DllCanUnloadNow nicht gefunden");
            }
            // Zeiger in Delegates konvertieren
            initializeEngine = (InitializeEngine)Marshal.GetDelegateForFunctionPointer(
                initializeEnginePtr, typeof(InitializeEngine));
            deinitializeEngine = (DeinitializeEngine)Marshal.GetDelegateForFunctionPointer(
                deinitializeEnginePtr, typeof(DeinitializeEngine));
            dllCanUnloadNow = (DllCanUnloadNow)Marshal.GetDelegateForFunctionPointer(
                dllCanUnloadNowPtr, typeof(DllCanUnloadNow));
            // InitializeEngine-Funktion aufrufen
            // und den Pfad zur Online-Lizenzdatei sowie das Online-Lizenzpasswort übergeben
            int hresult = initializeEngine(customerProjectId, licensePath, licensePassword, 
                "", "", false, ref engine);
            Marshal.ThrowExceptionForHR(hresult);
        }
        catch (Exception)
        {
            // FREngine.dll-Bibliothek freigeben
            engine = null;
            // Alle Objekte vor dem FreeLibrary-Aufruf löschen
            GC.Collect();
            GC.WaitForPendingFinalizers();
            GC.Collect();
            FreeLibrary(dllHandle);
            dllHandle = IntPtr.Zero;
            initializeEngine = null;
            deinitializeEngine = null;
            dllCanUnloadNow = null;
            throw;
        }
    }
    // Kernel32.dll-Funktionen
    [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);
    // FREngine.dll-Funktionen
    [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;
}

C++ (COM)

// Initialisieren Sie diese Variablen mit dem Pfad zu FREngine.dll, Ihrer FineReader Engine Customer Project ID
// und ggf. dem Pfad zum Online-Lizenz-Token und dem Online-Lizenz-Passwort
wchar_t* FreDllPath;
wchar_t* CustomerProjectId;
wchar_t* LicensePath;  // wenn Sie keine Online-Lizenz verwenden, weisen Sie diesen Variablen leere Strings zu
wchar_t* LicensePassword;
// HANDLE für FREngine.dll
static HMODULE libraryHandle = 0;
// Globales FineReader Engine-Objekt
FREngine::IEnginePtr Engine;
void LoadFREngine()
{
    if( Engine != 0 ) {
    // Bereits geladen
    return;
    }
    // Erster Schritt: FREngine.dll laden
    if( libraryHandle == 0 ) {
        libraryHandle = LoadLibraryEx( FreDllPath, 0, LOAD_WITH_ALTERED_SEARCH_PATH );
        if( libraryHandle == 0 ) {
            throw L"Fehler beim Laden von ABBYY FineReader Engine";
        }
    }
    // Zweiter Schritt: Engine-Objekt abrufen
    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"Fehler beim Laden von ABBYY FineReader Engine";
    }
}

Schritt 2. Laden der Einstellungen für das Szenario

ABBYY FineReader Engine ermöglicht das Laden aller Verarbeitungseinstellungen, die für dieses Szenario am besten geeignet sind, mithilfe der Methode LoadPredefinedProfile des Engine-Objekts. Diese Methode erhält den Profilnamen als Eingabeparameter. Weitere Informationen finden Sie unter Arbeiten mit Profilen.ABBYY FineReader Engine unterstützt 2 Einstellungsvarianten für dieses Szenario:

Profilname	Beschreibung
DocumentConversion_Accuracy	Die Einstellungen wurden auf maximale Genauigkeit optimiert: Beste Qualität. Aktiviert die Erkennung von Schriftstilen und die vollständige Rekonstruktion der logischen Struktur eines Dokuments.
DocumentConversion_Normal	Die Einstellungen wurden auf Verarbeitungsgeschwindigkeit optimiert: Beste Qualität. Aktiviert die Erkennung von Schriftstilen und die vollständige Rekonstruktion der logischen Struktur eines Dokuments. Die Bildausrichtung wird nicht korrigiert. Die Dokumentanalyse wird beschleunigt.

Profilname

Beschreibung

DocumentConversion_Accuracy

Die Einstellungen wurden auf maximale Genauigkeit optimiert:

Beste Qualität. Aktiviert die Erkennung von Schriftstilen und die vollständige Rekonstruktion der logischen Struktur eines Dokuments.

DocumentConversion_Normal

Die Einstellungen wurden auf Verarbeitungsgeschwindigkeit optimiert:

Beste Qualität. Aktiviert die Erkennung von Schriftstilen und die vollständige Rekonstruktion der logischen Struktur eines Dokuments.
Die Bildausrichtung wird nicht korrigiert.
Die Dokumentanalyse wird beschleunigt.

C#

// Ein vordefiniertes Profil laden
engine.LoadPredefinedProfile("DocumentConversion_Normal");

C++ (COM)

// Ein vordefiniertes Profil laden
Engine->LoadPredefinedProfile( L"DocumentConversion_Normal" );

Wenn Sie die Verarbeitungseinstellungen ändern möchten, verwenden Sie die entsprechenden Parameter-Objekte. Weitere Informationen finden Sie weiter unten unter Zusätzliche Optimierung für bestimmte Aufgaben.

Schritt 3. Laden und Vorverarbeiten der Bilder

ABBYY FineReader Engine stellt das Objekt FRDocument bereit, das die Verarbeitung mehrseitiger Dokumente ermöglicht. Durch die Verwendung dieses Objekts können Sie die logische Struktur des Dokuments beibehalten und den ursprünglichen Text sowie Spalten, Schriftarten, Stile usw. erhalten.Um Bilder eines einzelnen Dokuments zu laden und vorzuverarbeiten, sollten Sie das FRDocument-Objekt erstellen und Bilder hinzufügen. Dazu können Sie eine der folgenden Möglichkeiten verwenden:

Erstellen Sie das FRDocument-Objekt mit der Methode CreateFRDocumentFromImage des Engine-Objekts. Diese Methode erstellt das FRDocument-Objekt und lädt Bilder aus der angegebenen Datei.
Erstellen Sie das FRDocument-Objekt mithilfe der Methode CreateFRDocument des Engine-Objekts und fügen Sie dann dem erstellten FRDocument-Objekt Bilder aus einer Datei hinzu (verwenden Sie dazu die Methoden AddImageFile, AddImageFileWithPassword oder AddImageFileWithPasswordCallback des FRDocument-Objekts).

C#

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

C++ (COM)

// Das FRDocument-Objekt aus einer Bilddatei erstellen
FREngine::IFRDocumentPtr frDocument = Engine->CreateFRDocumentFromImage( L"C:\\MyImage.tif", 0 );

Die Bildvorverarbeitung mit dem geladenen Profil DocumentConversion_Normal umfasst keine Ausrichtungserkennung. Wenn Sie die Bildausrichtung automatisch erkennen lassen möchten, müssen Sie zusätzliche Parameter konfigurieren und das entsprechende Objekt an die Vorverarbeitungsfunktion übergeben. Weitere Informationen finden Sie weiter unten unter Zusätzliche Optimierung für bestimmte Aufgaben.

Schritt 4. Dokumenterkennung

Für die Erkennung eines Dokuments empfehlen wir, die Analyse- und Erkennungsmethoden des FRDocument-Objekts zu verwenden. Dieses Objekt bietet eine ganze Reihe von Methoden für Dokumentanalyse, Erkennung und Synthese. Die praktischste Methode, die Dokumentanalyse, Erkennung und Synthese in einem Schritt ermöglicht, ist Process. Sie nutzt außerdem die Funktionen zur parallelen Verarbeitung auf Multiprozessor- und Multicore-Systemen besonders effizient. Sie können die Vorverarbeitung, Analyse, Erkennung und Synthese aber auch nacheinander mit den Methoden Preprocess, Analyze, Recognize und Synthesize ausführen.

C#

// Das Dokument analysieren, erkennen und synthetisieren
// Zusätzliche Parameter sind nicht erforderlich, da sie im Verarbeitungsprofil festgelegt sind
frDocument.Process( null );

C++ (COM)

// Das Dokument analysieren, erkennen und synthetisieren
// Zusätzliche Parameter sind nicht erforderlich, da sie im Verarbeitungsprofil festgelegt sind
frDocument->Process( 0 );

Schritt 5. Dokumentexport

Zum Speichern eines erkannten Dokuments können Sie die Methode Export des Objekts FRDocument verwenden, indem Sie die Konstante FileExportFormatEnum als einen der Parameter angeben. Die Standardparameter für den Export können Sie über das entsprechende Exportobjekt ändern. Weitere Informationen finden Sie weiter unten unter Zusätzliche Optimierung für bestimmte Aufgaben.Wenn Sie Ihre Arbeit mit dem FRDocument-Objekt abgeschlossen haben, geben Sie alle von diesem Objekt verwendeten Ressourcen frei. Verwenden Sie dazu die Methode IFRDocument::Close.

C#

// Das erkannte Dokument in einem bearbeitbaren Format speichern (zum Beispiel RTF)
frDocument.Export( "C:\\MyText.rtf", FREngine.FileExportFormatEnum.FEF_RTF, null );
// Das FRDocument-Objekt freigeben
frDocument.Close();

C++ (COM)

// Das erkannte Dokument in einem bearbeitbaren Format speichern (zum Beispiel RTF)
frDocument->Export( L"C:\\MyText.rtf", FREngine::FEF_RTF, 0 );
// Das FRDocument-Objekt freigeben
frDocument->Close();

Schritt 6. 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;
        // Nach dem Bereinigen eine Ausnahme 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;
}

C++ (COM)

void UnloadFREngine()
{
 if( libraryHandle == 0 ) {
  return;
 }
 // Engine-Objekt freigeben
 Engine = 0;
 // FineReader Engine deinitialisieren
 typedef HRESULT ( STDAPICALLTYPE* DeinitializeEngineFunc )();
 DeinitializeEngineFunc pDeinitializeEngine =
  ( DeinitializeEngineFunc )GetProcAddress( libraryHandle, "DeinitializeEngine" );
 if( pDeinitializeEngine == 0 || pDeinitializeEngine() != S_OK ) {
  throw L"Error while unloading ABBYY FineReader Engine";
 }
 // Jetzt kann die Bibliothek FREngine.dll sicher freigegeben werden
 FreeLibrary( libraryHandle );
 libraryHandle = 0;
}

Erforderliche Ressourcen

Sie können die Datei FREngineDistribution.csv verwenden, um automatisch eine Liste der Dateien zu erstellen, die für den Betrieb Ihrer Anwendung erforderlich sind. 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 Sprachen der Benutzeroberfläche, die Erkennungssprachen und alle zusätzlichen Funktionen angeben, die Ihre Anwendung verwendet (wie 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 Working with the FREngineDistribution.csv File.

Zusätzliche Optimierung für bestimmte Aufgaben

Nachfolgend finden Sie eine Übersicht über die Hilfethemen mit zusätzlichen Informationen zur Anpassung von Einstellungen in verschiedenen Phasen der Dokumentkonvertierung in ein bearbeitbares Format:

Scannen – nur unter Windows
- Scannen
  Beschreibung des ABBYY FineReader Engine-Szenarios zum Scannen von Dokumenten.
Erkennung
- Parameter für Vorverarbeitung, Analyse, Erkennung und Synthese anpassen
  Anpassung der Dokumentverarbeitung mithilfe von Objekten für Analyse-, Erkennungs- und Syntheseparameter.
- Handschrift erkennen
  Die DocumentConversion_***-Profile unterstützen keine Erkennung von handschriftlichem oder handgedrucktem Text. Wenn Sie Handschrift erkennen müssen, setzen Sie die Eigenschaft DetectHandwritten des Objekts PageAnalysisParams auf TRUE.
- PageProcessingParams Object
  Dieses Objekt ermöglicht die Anpassung von Analyse- und Erkennungsparametern. Damit können Sie festlegen, welche Bild- und Texteigenschaften erkannt werden sollen (invertiertes Bild, Ausrichtung, Barcodes, Erkennungssprache, Fehlertoleranz bei der Erkennung).
- SynthesisParamsForPage Object
  Dieses Objekt enthält Parameter für die Wiederherstellung der Seitenformatierung während der Synthese.
- SynthesisParamsForDocument Object
  Dieses Objekt ermöglicht die Anpassung der Dokumentsynthese: die Wiederherstellung von Struktur und Formatierung.
- MultiProcessingParams Object - Implementiert für Linux und Windows
  Die gleichzeitige Verarbeitung kann bei einer großen Anzahl von Bildern nützlich sein. Dabei wird die Verarbeitungslast beim Öffnen und Vorverarbeiten von Bildern, bei der Layout-Analyse, der Erkennung und beim Export auf die Prozessorkerne verteilt, was die Verarbeitung beschleunigen kann.
  Die Verarbeitungsmodi (gleichzeitig oder nacheinander) werden über die Eigenschaft MultiProcessingMode festgelegt. Die Eigenschaft RecognitionProcessesCount steuert die Anzahl der Prozesse, die gestartet werden können.
Export
- Exportparameter anpassen
  Anpassung des Dokumentexports mithilfe von Objekten für Exportparameter.
- RTFExportParams Object
  Dieses Objekt ermöglicht die Anpassung der Parameter für das Speicherformat RTF/DOCX/ODT.
- HTMLExportParams Object
  Dieses Objekt ermöglicht die Anpassung des Exports in das HTML-Format.
- PPTExportParams Object
  Objekt zur Anpassung der Parameter für das Speicherformat PPTX.

Siehe auch

Implementierung grundlegender Anwendungsszenarien

Overview

Basic Usage Scenarios Implementation

Advanced Techniques

Umsetzung des Szenarios

C#

C++ (COM)

C#

C++ (COM)

C#

C++ (COM)

C#

C++ (COM)

C#

C++ (COM)

C#

C++ (COM)

Erforderliche Ressourcen

Zusätzliche Optimierung für bestimmte Aufgaben

Siehe auch

​Umsetzung des Szenarios

C#

C++ (COM)

C#

C++ (COM)

C#

C++ (COM)

C#

C++ (COM)

C#

C++ (COM)

C#

C++ (COM)

​Erforderliche Ressourcen

​Zusätzliche Optimierung für bestimmte Aufgaben

​Siehe auch

Umsetzung des Szenarios

Erforderliche Ressourcen

Zusätzliche Optimierung für bestimmte Aufgaben

Siehe auch