> ## 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. # Erkennung von Visitenkarten > Erfassen Sie Visitenkartendaten mit ABBYY FineReader Engine und exportieren Sie sie in vCard oder andere elektronische Formate — Extraktion von Name, Unternehmen, Telefon, E-Mail und Website. 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](/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 weiterer 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 // 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](/de/fine-reader/engine/api-reference/engine-object-iengine-interface/supplementary-methods/loadpredefinedprofile-method) des Engine-Objekts laden. Diese Methode verwendet den Namen eines Einstellungsprofils als Eingabeparameter. Weitere Informationen finden Sie unter [Arbeiten mit Profilen](/de/fine-reader/engine/guided-tour/advanced-techniques/working-with-profiles). Die Einstellungen für dieses Szenario sind im vordefinierten Profil [BusinessCardsProcessing](/de/fine-reader/engine/guided-tour/advanced-techniques/working-with-profiles#businesscardsprocessing) verfügbar: * Erkennt nur Visitenkarten (setzt die Eigenschaft [SynthesizeBusinessCards](/de/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/synthesisparamsforpage#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\# ```csharp theme={null} // 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](/de/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation/business-card-recognition#optimization). Zum Laden von Bildern in FineReader Engine können Sie die Methoden der folgenden Objekte verwenden: * [FRDocument](/de/fine-reader/engine/api-reference/document-related-objects/frdocument) * [BatchProcessor](/de/fine-reader/engine/api-reference/batch-processor/batchprocessor) für Linux und Windows Linux- und Windows-Benutzer können sich unter [Parallele Verarbeitung mit ABBYY FineReader Engine](/de/fine-reader/engine/guided-tour/advanced-techniques/parallel-processing) ü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: * Verwenden Sie beim Erstellen des FRDocument-Objekts die Methode [CreateFRDocumentFromImage](/de/fine-reader/engine/api-reference/engine-object-iengine-interface/creation-methods/createfrdocumentfromimage-method) des Objekts [Engine](/de/fine-reader/engine/api-reference/engine-object-iengine-interface). * Fügen Sie dem erstellten FRDocument-Objekt Bilder aus einer Datei hinzu (verwenden Sie dazu die Methode [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)). Alle diese Methoden verwenden das Objekt [PrepareImageMode](/de/fine-reader/engine/api-reference/image-related-objects/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](/de/fine-reader/engine/api-reference/engine-object-iengine-interface/creation-methods/createlessobjectgreater-methods), ändern Sie anschließend seine Eigenschaften nach Bedarf und übergeben Sie es dann an eine Funktion, die es benötigt. ### C\# ```csharp theme={null} 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](/de/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/recognizerparams/setpredefinedtextlanguage-method) des RecognizerParams-Objekts an. Eine [Liste der vordefinierten Sprachen](/de/fine-reader/engine/specifications/predefined-languages), 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](/de/fine-reader/engine/guided-tour/advanced-techniques/tuning-parameters-of-preprocessing-analysis-recognition-and-synthesis). 3. Übergeben Sie die Parameter an eine beliebige Verarbeitungsmethode (z. B. an die Methode [Process](/de/fine-reader/engine/api-reference/document-related-objects/frdocument/process-method) des FRDocument-Objekts). Die Methode füllt die Visitenkartensammlungen des Dokuments und seiner Seiten ([IFRDocument::BusinessCards](/de/fine-reader/engine/api-reference/document-related-objects/frdocument#businesscards), [IFRPage::BusinessCards](/de/fine-reader/engine/api-reference/document-related-objects/frpage#businesscards)). Sie können eine Visitenkarte auch aus einer ganzen Seite oder einem Bereich auf einer Seite mit der Methode [SynthesizeBusinessCard](/de/fine-reader/engine/api-reference/document-related-objects/frpage/synthesizebusinesscard-method) oder [SynthesizeBusinessCardEx](/de/fine-reader/engine/api-reference/document-related-objects/frpage/synthesizebusinesscardex-method) des FRPage-Objekts synthetisieren. Die Methode gibt ein [BusinessCard](/de/fine-reader/engine/api-reference/document-related-objects/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\# ```csharp theme={null} // 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](/de/fine-reader/engine/api-reference/document-related-objects/businesscard)-Objekt) kann die folgenden Felder enthalten:

BusinessCard_pict

Sie können auf jedes Feld über seinen Typ (Eigenschaft [FieldByType](/de/fine-reader/engine/api-reference/document-related-objects/businesscard/fieldbytype-property)) oder über seinen Index in der Feldsammlung (Eigenschaft [Field](/de/fine-reader/engine/api-reference/document-related-objects/businesscard/field-property)) zugreifen. Jedes Feld verfügt über die Eigenschaft [Value](/de/fine-reader/engine/api-reference/document-related-objects/businesscardfield#value), die Zugriff auf den Feldwert im string-Format bietet. Für jedes Zeichen im Feld sind Erkennungsvarianten verfügbar (Methode [GetCharParams](/de/fine-reader/engine/api-reference/document-related-objects/businesscardfield/getcharparams-method)). 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](/de/fine-reader/engine/api-reference/document-related-objects/businesscardfield/component-property) oder die Methode [FindComponent](/de/fine-reader/engine/api-reference/document-related-objects/businesscardfield/findcomponent-method) 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](/de/fine-reader/engine/api-reference/document-related-objects/businesscardfieldcomponent/getcharparams-method)). ### C\# ```csharp theme={null} // 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](/de/fine-reader/engine/api-reference/document-related-objects/businesscard/exporttovcard-method) 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\# ```csharp theme={null} // 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](/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; // 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](/de/fine-reader/engine/distribution/distribution-windows/distribution-kit/working-with-the-frenginedistributioncsv-file) 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](/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).
## Zusätzliche Optimierung
Dies sind die Abschnitte der Hilfedatei, in denen Sie weitere Informationen zur Konfiguration der Parameter für die verschiedenen Verarbeitungsschritte finden: * Laden der Engine * [Verschiedene Möglichkeiten zum Laden des Engine-Objekts](/de/fine-reader/engine/guided-tour/advanced-techniques/programming-aspects/different-ways-to-load-engine) für Windows
Beschreibt die verschiedenen Möglichkeiten zum Laden des Engine-Objekts im Detail. * [Verwenden von ABBYY FineReader Engine in Multithread-Serveranwendungen](/de/fine-reader/engine/guided-tour/advanced-techniques/programming-aspects/using-in-server-applications) für Windows
Behandelt die Besonderheiten bei der Verwendung von FineReader Engine in Serveranwendungen. * [Arbeiten mit Profilen](/de/fine-reader/engine/guided-tour/advanced-techniques/working-with-profiles)
Bietet eine ausführliche Beschreibung vordefinierter und benutzerdefinierter Profile. * Erkennung * [Optimieren 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)
Anpassen der Dokumentverarbeitung mithilfe von Parameterobjekten für Vorverarbeitung, Analyse, Erkennung und Synthese. * [Parallele Verarbeitung mit ABBYY FineReader Engine](/de/fine-reader/engine/guided-tour/advanced-techniques/parallel-processing) für Linux und Windows
Sie können auch eine andere Methode der Dokumentverarbeitung verwenden, bei der der Batch Processor eingesetzt wird. * Export * [Exportparameter optimieren](/de/fine-reader/engine/guided-tour/advanced-techniques/tuning-export-parameters)
Konfigurieren des Exports mithilfe von Exportparameterobjekten. * [XMLExportParams-Objekt](/de/fine-reader/engine/api-reference/parameter-objects/export-parameters/xmlexportparams)
Mit diesem Objekt können Sie das Speichern von Erkennungsergebnissen im XML-Format konfigurieren.
## Siehe auch
[Implementierung grundlegender Anwendungsszenarien](/de/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation)