Zum Hauptinhalt springen

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.

Visitenkarten enthalten geschäftliche Informationen über ein Unternehmen oder eine Person. Sie können den Namen einer Person, den Firmennamen, Telefonnummern, Faxnummern, E-Mail-Adressen, Website-Adressen und ähnliche Angaben enthalten. Möglicherweise müssen Sie diese Informationen von gedruckten Visitenkarten erfassen und in einem elektronischen Format speichern. Das kann ein elektronisches Adressbuch auf einem Mobiltelefon, in einem E-Mail-Client oder in einem anderen Datenspeichersystem sein. Beispielsweise werden Visitenkarten häufig per E-Mail oder über ein Netzwerk im vCard-Format weitergegeben. Die wichtigsten Schritte, die Sie in diesem Szenario ausführen müssen:
  1. Beschaffung einer digitalen Kopie einer Visitenkarte Sie scannen eine Visitenkarte oder machen ein Foto davon. Fotos, die mit den Digitalkameras mobiler Geräte aufgenommen werden, können eine geringe Auflösung und Qualität aufweisen. Daher kann eine zusätzliche Vorbereitung der Bilder erforderlich sein.
  2. Erkennung von Visitenkarten Gescannte Seiten können mehrere Visitenkarten pro Seite enthalten. Die Erkennung muss eine hohe Qualität aufweisen; alle Informationen müssen präzise extrahiert werden.
  3. Speichern der erkannten Daten in einem geeigneten Format Sie können die erkannten Daten in verschiedenen Datenspeichersystemen speichern oder in das vCard-Format exportieren und per E-Mail weiterleiten.

​
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.
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 weiterer 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
        // sowie, falls zutreffend, dem Pfad zu Ihrer Online License-Token-Datei und dem Online License-Passwort
        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 umwandeln
            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 dabei den Pfad zur Online License-Datei und das Online License-Passwort ü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;
}
Sie können die für dieses Szenario geeigneten Verarbeitungseinstellungen mit der Methode LoadPredefinedProfile des Engine-Objekts laden. Diese Methode verwendet den Namen eines Einstellungsprofils als Eingabeparameter. Weitere Informationen finden Sie unter Arbeiten mit Profilen.Die Einstellungen für dieses Szenario sind im vordefinierten Profil BusinessCardsProcessing verfügbar:
  • Erkennt nur Visitenkarten (setzt die Eigenschaft SynthesizeBusinessCards des Objekts SynthesisParamsForPage auf TRUE).
  • Aktiviert die Erkennung des gesamten Textes in einem Bild, einschließlich kleiner Textbereiche mit geringer Qualität (Bilder und Tabellen werden nicht erkannt).
  • Es wird eine Auflösungskorrektur durchgeführt.
  • Eine vollständige Synthese der logischen Struktur eines Dokuments erfolgt nicht.

​
C#

// Das vordefinierte Profil laden
engine.LoadPredefinedProfile("BusinessCardsProcessing");
Wenn Sie die Verarbeitungseinstellungen ändern möchten, verwenden Sie die entsprechenden Parameterobjekte. Weitere Informationen finden Sie weiter unten unter Zusätzliche Optimierung für bestimmte Aufgaben.
Zum Laden von Bildern in FineReader Engine können Sie die Methoden der folgenden Objekte verwenden:
Linux- und Windows-Benutzer können sich unter Parallele Verarbeitung mit ABBYY FineReader Engine über die Vor- und Nachteile der beiden Ansätze informieren. In diesem Thema liegt der Schwerpunkt auf FRDocument.
Um Bilder in das FRDocument-Objekt zu laden, gehen Sie wie folgt vor:Alle diese Methoden verwenden das Objekt PrepareImageMode als Parameter, mit dem Sie verschiedene Parameter für die Bildvorverarbeitung angeben können. Erstellen Sie dieses Objekt durch Aufruf der Funktion IEngine::CreatePrepareImageMode, ändern Sie anschließend seine Eigenschaften nach Bedarf und übergeben Sie es dann an eine Funktion, die es benötigt.

​
C#

FREngine.IEngine engine;
string imagePath;
FREngine.IPrepareImageMode pim = engine.CreatePrepareImageMode();
pim.DocumentType = FREngine.DocumentTypeEnum.DT_BusinessCard;
FREngine.IFRDocument frDoc = engine.CreateFRDocument();
frDoc.AddImageFile(imagePath, pim, null);
So erkennen Sie Visitenkarten:
  1. Geben Sie die Sprache der Visitenkarten mit der Methode SetPredefinedTextLanguage des RecognizerParams-Objekts an. Eine Liste der vordefinierten Sprachen, die für die Visitenkartenerkennung verfügbar sind, finden Sie hier.
  2. Legen Sie bei Bedarf weitere Verarbeitungsparameter fest. Siehe Parameter für Seitenvorverarbeitung, Analyse, Erkennung und Synthese abstimmen.
  3. Übergeben Sie die Parameter an eine beliebige Verarbeitungsmethode (z. B. an die Methode Process des FRDocument-Objekts). Die Methode füllt die Visitenkartensammlungen des Dokuments und seiner Seiten (IFRDocument::BusinessCards, IFRPage::BusinessCards).
Sie können eine Visitenkarte auch aus einer ganzen Seite oder einem Bereich auf einer Seite mit der Methode SynthesizeBusinessCard oder SynthesizeBusinessCardEx des FRPage-Objekts synthetisieren. Die Methode gibt ein BusinessCard-Objekt zurück. Beachten Sie, dass in diesem Fall keine Visitenkarte zur Visitenkartensammlung der Seite hinzugefügt wird. Diese Vorgehensweise ist besonders nützlich, wenn Sie eine Verarbeitungsart wählen, die den Batch Processor verwendet.

​
C#

// Parameter für die Dokumentverarbeitung erstellen
FREngine.IDocumentProcessingParams dpp = engine.CreateDocumentProcessingParams();
// Erkennung mit den angegebenen Parametern durchführen
frDoc.Process( dpp );
// Auf eine Visitenkarte zugreifen
FREngine.IBusinessCard card = frDoc.BusinessCards[0];
Eine erkannte Visitenkarte (das BusinessCard-Objekt) kann die folgenden Felder enthalten:

BusinessCard_pict

  • Name
  • Firmenname
  • Position im Unternehmen
  • Firmenadresse
  • Telefonnummer
  • Fax
  • Mobiltelefonnummer
  • E-Mail
  • Website
Sie können auf jedes Feld über seinen Typ (Eigenschaft FieldByType) oder über seinen Index in der Feldsammlung (Eigenschaft Field) zugreifen. Jedes Feld verfügt über die Eigenschaft Value, die Zugriff auf den Feldwert im string-Format bietet. Für jedes Zeichen im Feld sind Erkennungsvarianten verfügbar (Methode GetCharParams).Einige Felder können aus mehreren Komponenten bestehen, z. B. kann das Adressfeld eine Postleitzahl, ein Land, einen Bundesstaat der USA, eine Stadt und eine Straßenadresse enthalten. Um auf eine Feldkomponente zuzugreifen, können Sie die Eigenschaft Component oder die Methode FindComponent verwenden. Mit der ersten können Sie über ihren Index auf die Komponente zugreifen, mit der zweiten wird die Komponente anhand ihres Typs gefunden. Für jede Komponente können Sie ihren Typ und ihren Wert anzeigen sowie Parameter und Erkennungsvarianten für jedes Zeichen abrufen (Methode GetCharParams).

​
C#

// Das Namensfeld abrufen
FREngine.IBusinessCardField nameField = card.FieldByType( FREngine.BusinessCardFieldTypeEnum.BCFT_Name, 0 );
// Die Komponente abrufen, die den Vornamen enthält
FREngine.IBusinessCardFieldComponent firstNameComponent =
  nameField.FindComponent( FREngine.BusinessCardFieldComponentTypeEnum.BCFCT_FirstName );
// Der erkannte Vorname
string firstName = firstNameComponent.Value;
Das BusinessCard-Objekt stellt die spezielle Methode ExportToVCard zum Speichern einer Visitenkarte im vCard-Format bereit. Der Dateipfad wird als Parameter übergeben.Sie können die Visitenkarte auch in jedem anderen verfügbaren Exportformat speichern, zum Beispiel in XML.

​
C#

// Erkannte Daten im vCard-Format speichern
card.ExportToVCard("D:\\sample.vcf");
// In XML speichern
frDoc.Export("D:\\Demo.xml", FREngine.FileExportFormatEnum.FEF_XML, null);
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 von 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 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.BCR 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. Sie müssen außerdem 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

Dies sind die Abschnitte der Hilfedatei, in denen Sie weitere Informationen zur Konfiguration der Parameter für die verschiedenen Verarbeitungsschritte finden:

​
Siehe auch

Implementierung grundlegender Anwendungsszenarien