Felderkennung - ABBYY Documentation

Bei der Felderkennung werden kurze Textfragmente erkannt, um Daten aus bestimmten Feldern zu erfassen. Die Erkennungsqualität ist in diesem Szenario entscheidend. Dieses Szenario kann auch als Teil komplexerer Szenarien verwendet werden, in denen aussagekräftige Daten aus Dokumenten extrahiert werden sollen (zum Beispiel, um Daten aus Papierdokumenten in Informationssysteme und Datenbanken zu übernehmen oder Dokumente in Dokumentenmanagementsystemen automatisch zu klassifizieren und zu indizieren). In diesem Szenario erkennt das System entweder mehrere Textzeilen in nur einigen Feldern oder den gesamten Text in einem kleinen Bild. Das System berechnet für jedes erkannte Zeichen einen Konfidenzwert. Diese Konfidenzwerte können dann bei der Überprüfung der Erkennungsergebnisse verwendet werden. Außerdem kann das System mehrere Erkennungsvarianten für Wörter und Zeichen im Text speichern, die anschließend in Abstimmungsalgorithmen verwendet werden können, um die Erkennungsqualität zu verbessern. Die Verarbeitung kleiner Textfragmente unterscheidet sich in diesem Szenario in mancher Hinsicht von denselben Schritten in anderen Szenarien:

Vorverarbeitung gescannter Bilder oder Fotos

Die zu erkennenden Bilder können Markierungen und Bildrauschen enthalten, die die Erkennung beeinträchtigen können. Aus diesem Grund werden in dieser Phase unerwünschte Markierungen und Bildrauschen entfernt.

Erkennung kleiner Textfragmente

Bei der Erkennung kleiner Textfragmente ist der Typ der zu erkennenden Daten im Voraus bekannt. Daher kann die Erkennungsqualität durch den Einsatz externer Wörterbücher, regulärer Ausdrücke, benutzerdefinierter Erkennungssprachen und Alphabete sowie durch Beschränkungen der Anzahl von Zeichen in einer Zeichenfolge verbessert werden. Textfelder können gedruckten Text, in Druckschrift geschriebenen Text und Handschrift enthalten.

Arbeiten mit den erkannten Daten

Dieses Szenario erfordert eine maximale Erkennungsgenauigkeit, um den Aufwand für die Datenüberprüfung auf ein Minimum zu reduzieren. Das System kann für jedes erkannte Wort oder Zeichen einen Konfidenzwert berechnen und mehrere Erkennungsvarianten bereitstellen, aus denen anschließend mehrere Engines durch Anwendung von Abstimmungsalgorithmen den besten Kandidaten auswählen können.

Implementierung des Szenarios

Die in diesem Thema bereitgestellten Codebeispiele sind Windows-spezifisch.

Im Folgenden finden Sie eine ausführliche Beschreibung der empfohlenen Vorgehensweise für die Verwendung von ABBYY FineReader Engine 12 in diesem Szenario. Dabei werden Verarbeitungseinstellungen verwendet, die für dieses Szenario als besonders geeignet gelten.

Schritt 1. ABBYY FineReader Engine laden

Um mit ABBYY FineReader Engine zu arbeiten, müssen Sie zunächst das Engine-Objekt erstellen. Das Engine-Objekt steht an der Spitze der Objekthierarchie von ABBYY FineReader Engine und stellt verschiedene globale Einstellungen, einige Verarbeitungsmethoden sowie Methoden zum Erstellen weiterer Objekte bereit.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

Die am besten geeigneten Einstellungen lassen sich mit der Methode LoadPredefinedProfile des Objekts Engine auswählen. Diese Methode erhält den Profilnamen als Eingabeparameter. Für diesen Zweck eignet sich das vordefinierte Profil FieldLevelRecognition. Weitere Informationen zu Profilen finden Sie unter Working with Profiles.

C#

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

C++ (COM)

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

Wenn Sie die für die Verarbeitung verwendeten Einstellungen ändern möchten, verwenden Sie die entsprechenden Parameter-Objekte. Weitere Informationen finden Sie unten im Abschnitt Additional optimization.

Schritt 3. Laden und Vorverarbeiten der Bilder

ABBYY FineReader Engine stellt das Objekt FRDocument für die Verarbeitung mehrseitiger Dokumente bereit. Um die Bilder eines Dokuments zu laden und vorzuverarbeiten, sollten Sie ein FRDocument-Objekt erstellen und ihm Bilder hinzufügen. Sie können dabei eine der folgenden Vorgehensweisen wählen:

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

C#

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

C++ (COM)

// Eine Bilddatei öffnen und das FRDocument-Objekt erstellen
FREngine::IFRDocumentPtr frDocument = Engine->CreateFRDocumentFromImage( L"C:\\MyImage.tif", 0 );

Schritt 4. Einrichten der zu erkennenden Felder

Nun müssen Sie Blöcke erstellen, die Ihre Felder enthalten, und für jeden davon den Blocktyp sowie bekannte Merkmale der darin enthaltenen Daten angeben.Führen Sie die Layout-Analyse des Dokuments mit der Methode Analyze durch, oder fügen Sie die Blöcke mit den Feldern, die Sie erkennen möchten, manuell hinzu. Anweisungen dazu finden Sie unter Working with Layout and Blocks.Für jedes Feld können Sie nun eigene Erkennungsparameter angeben. Wenn ein Feld beispielsweise Text enthält, verwenden Sie die Eigenschaft ITextBlock::RecognizerParams:

legen Sie den Texttyp mithilfe der Eigenschaft TextTypes des Objekts RecognizerParams fest. Wenn das Feld z. B. Ziffern im Stil einer Postleitzahl enthält, verwenden Sie den Texttyp TT_Index.
legen Sie die Sprache mit der Methode SetPredefinedTextLanguage fest. Die Verwendung spezieller vordefinierter Sprachen (nur unter Windows) kann hilfreich sein, wenn Sie wissen, welche Art von Informationen das Feld enthält. Wenn das Feld z. B. eine Adresse in den USA enthält, wählen Sie die vordefinierte Sprache English_US_Address. Dadurch wird sichergestellt, dass der Text zuverlässiger erkannt wird.
legen Sie die Eigenschaften SaveCharacterRecognitionVariants und SaveWordRecognitionVariants des Objekts RecognizerParams fest, wenn Sie die Erkennungsvarianten zur weiteren Überprüfung des Ergebnisses benötigen, wie unten in Schritt 6 beschrieben. Beachten Sie, dass diese Einstellung für handschriftliche oder in Druckschrift geschriebene Texte nicht verfügbar ist.

Weitere Informationen zur Erkennung verschiedener Feldtypen finden Sie in den Abschnitten Erkennen von Häkchen, Erkennen handschriftlicher Texte, Recognizing Barcodes und Erkennen von Wörtern mit Leerzeichen.

C#

// Dokumentlayout analysieren
frDocument.Analyze( null, null, null );
// Angenommen, wir wissen, dass der erste Block
// im Layout eine Adresse in den USA enthält
FREngine.ITextBlock addressBlock = frDocument.Pages[0].Layout.Blocks[0].GetAsTextBlock();
FREngine.IRecognizerParams paramsAddressBlock = addressBlock.RecognizerParams;
paramsAddressBlock.SetPredefinedTextLanguage( "English_US_Address" );
// Erfassen von Erkennungsvarianten aktivieren
paramsAddressBlock.SaveCharacterRecognitionVariants = true;
paramsAddressBlock.SaveWordRecognitionVariants = true;
// Eigenschaften anderer Layout-Blöcke auf dieselbe Weise festlegen
...

C++ (COM)

// Dokumentlayout analysieren
frDocument->Analyze( 0, 0, 0 );
// Angenommen, wir wissen, dass der erste Block
// im Layout eine Adresse in den USA enthält
FREngine::ILayoutBlocksPtr layoutBlocks = frDocument->Pages->Item( 0 )->Layout->Blocks;
FREngine::IRecognizerParamsPtr paramsAddressBlock = layoutBlocks->Item( 0 )->GetAsTextBlock()->RecognizerParams;
paramsAddressBlock->SetPredefinedTextLanguage( L"English_US_Address" );
// Erfassen von Erkennungsvarianten aktivieren
paramsAddressBlock->SaveCharacterRecognitionVariants = VARIANT_TRUE;
paramsAddressBlock->SaveWordRecognitionVariants = VARIANT_TRUE;
// Eigenschaften anderer Layout-Blöcke auf dieselbe Weise festlegen
...

Schritt 5. Erkennung

Da das Dokumentlayout bereits analysiert und zusätzlich von Ihnen geändert wurde, rufen Sie die Analysemethoden nicht noch einmal auf. Verwenden Sie die Methode Recognize, die für alle Seiten im Dokument die Erkennung und Seitensynthese durchführt. In diesem Szenario müssen Sie die Daten aus Feldern extrahieren und das erkannte Dokument nicht exportieren, daher benötigen Sie keine Dokumentsynthese.

C#

// Das Dokument erkennen
// Es müssen keine Parameter angegeben werden, da sie durch das Verarbeitungsprofil festgelegt sind
frDocument.Recognize( null, null );

C++ (COM)

// Das Dokument erkennen
// Es müssen keine Parameter angegeben werden, da sie durch das Verarbeitungsprofil festgelegt sind
frDocument->Recognize( 0, 0 );

Schritt 6. Mit den erkannten Daten arbeiten

Verwenden Sie das Objekt Text, um auf das erkannte Textfragment zuzugreifen (Sie können dieses Objekt für einen Textblock über die Eigenschaft ITextBlock::Text abrufen). Verwenden Sie die Eigenschaft Paragraphs, um die Sammlung der Absätze im Fragment abzurufen, und die Methode IParagraphs::Item, um auf einzelne Absätze zuzugreifen. Die Eigenschaft IParagraph::Text bietet Zugriff auf den erkannten Text eines Absatzes.Sie können IParagraph::Words verwenden, um die Wortsammlung eines Absatzes abzurufen. Verwenden Sie die Methode IWords::Item, um auf einzelne Wörter in der Sammlung zuzugreifen. Die Eigenschaft IWord::Text gibt die Zeile zurück, die das erkannte Wort enthält. Verwenden Sie die Methode GetRecognitionVariants des Word-Objekts oder die Methode GetWordRecognitionVariants des Paragraph-Objekts, um die Erkennungsvarianten für ein Wort abzurufen.Auf die Attribute einzelner Zeichen kann über die Methode GetCharParams des Paragraph-Objekts zugegriffen werden. Diese Methode bietet Zugriff auf das Objekt CharParams, das die Parameter des erkannten Zeichens enthält. Auf die Erkennungsvarianten eines Zeichens kann über die Eigenschaft ICharParams::CharacterRecognitionVariants zugegriffen werden.Ausführliche Informationen zur Arbeit mit Text finden Sie unter Arbeiten mit Text. Informationen zur Verwendung der Engine in Voting-Algorithmen finden Sie unter Verwenden der Voting API.Nachdem Sie Ihre Arbeit mit dem Objekt FRDocument abgeschlossen haben, geben Sie alle von diesem Objekt verwendeten Ressourcen frei. Verwenden Sie dazu die Methode IFRDocument::Close.

Schritt 7. ABBYY FineReader Engine entladen

Nachdem Sie die Arbeit mit ABBYY FineReader Engine beendet 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 löschen
        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;
}

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 die Ausführung 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 Wenn Sie das Standardszenario ändern, passen Sie die erforderlichen Module entsprechend an. Sie müssen außerdem die Oberflächensprachen, Erkennungssprachen und alle zusätzlichen Funktionen angeben, die von Ihrer Anwendung verwendet werden (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

In den folgenden Abschnitten der Hilfedatei finden Sie weitere Informationen zum Einrichten der Parameter für die verschiedenen Verarbeitungsstufen:

Erkennung
- Arbeiten mit Sprachen
  Verwendung integrierter und benutzerdefinierter Erkennungssprachen.
- Arbeiten mit Wörterbüchern
  Verwendung von Wörterbüchern zur Verbesserung der Erkennungsqualität.
- Erkennen von Wörtern mit Leerzeichen
  Verwendung von Wörterbüchern zum Erkennen von Wörtern mit Leerzeichen (z. B. New York).
- Erkennen handschriftlicher Texte
  Verwendung von ICR (Intelligent Character Recognition).
- Erkennen von Häkchen
  Einrichten der Erkennung von Häkchen und Häkchengruppen.
- Spezielle vordefinierte Sprachen in ABBYY FineReader Engine - Windows
  Liste der Erkennungssprachen, die spezielle Spracheinheiten enthalten: Adressen, Datum und Uhrzeit, Personennamen usw. Diese Sprachen können für die Felderkennung verwendet werden.
Arbeiten mit den erkannten Daten
- Arbeiten mit Text
  Arbeiten mit erkanntem Text, Absätzen, Wörtern und Zeichen.
- Verwenden der Voting API
  Arbeiten mit Wörtern und Alternativen der Zeichenerkennung.

Siehe auch

Implementierung grundlegender Anwendungsszenarien

Documentation Index

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

​Siehe auch

Implementierung 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

Siehe auch