> ## 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.

# Felderkennung

> Erkennen Sie kurze Textfragmente — Felder in Formularen oder gescannten Dokumenten — mit ABBYY FineReader Engine, mit Einstellungen für hohe Genauigkeit, Konfidenzwerten und Abstimmung für die Verifizierung.

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:

1. 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.

2. 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.

3. 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.

<div id="scenario-implementation">
  ## Implementierung des Szenarios
</div>

<Note>
  Die in diesem Thema bereitgestellten Codebeispiele sind Windows-spezifisch.
</Note>

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.

<Accordion title="Schritt 1. ABBYY FineReader Engine laden">
  Um mit ABBYY FineReader Engine zu arbeiten, müssen Sie zunächst das [Engine](/de/fine-reader/engine/api-reference/engine-object-iengine-interface)-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](/de/fine-reader/engine/api-reference/functions/initializeengine-function) verwenden. Siehe auch [andere 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,
          // 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)

  ```cpp theme={null}
  // 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";
      }
  }
  ```
</Accordion>

<Accordion title="Schritt 2. Laden der Einstellungen für das Szenario">
  Die am besten geeigneten Einstellungen lassen sich mit der Methode [LoadPredefinedProfile](/de/fine-reader/engine/api-reference/engine-object-iengine-interface/supplementary-methods/loadpredefinedprofile-method) des Objekts [Engine](/de/fine-reader/engine/api-reference/engine-object-iengine-interface) 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](/de/fine-reader/engine/guided-tour/advanced-techniques/working-with-profiles).

  ### C\#

  ```csharp theme={null}
  // Ein vordefiniertes Profil laden
  engine.LoadPredefinedProfile("FieldLevelRecognition");
  ```

  ### C++ (COM)

  ```cpp theme={null}
  // 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](/de/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation/field-level-recognition#optimization).
</Accordion>

<Accordion title="Schritt 3. Laden und Vorverarbeiten der Bilder">
  ABBYY FineReader Engine stellt das Objekt [FRDocument](/de/fine-reader/engine/api-reference/document-related-objects/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](/de/fine-reader/engine/api-reference/engine-object-iengine-interface/creation-methods/createfrdocumentfromimage-method) 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](/de/fine-reader/engine/api-reference/engine-object-iengine-interface/creation-methods/createlessobjectgreater-methods) des Objekts Engine und fügen Sie dann die Bilder aus einer Datei zum erstellten FRDocument-Objekt 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) des Objekts FRDocument).

  ### C\#

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

  ### C++ (COM)

  ```cpp theme={null}
  // Eine Bilddatei öffnen und das FRDocument-Objekt erstellen
  FREngine::IFRDocumentPtr frDocument = Engine->CreateFRDocumentFromImage( L"C:\\MyImage.tif", 0 );
  ```
</Accordion>

<Accordion title="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](/de/fine-reader/engine/api-reference/document-related-objects/frdocument/analyze-method) 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](/de/fine-reader/engine/guided-tour/advanced-techniques/working-with-layout-and-blocks#adding_manually).

  Für jedes Feld können Sie nun eigene Erkennungsparameter angeben. Wenn ein Feld beispielsweise Text enthält, verwenden Sie die Eigenschaft [ITextBlock::RecognizerParams](/de/fine-reader/engine/api-reference/layout-related-objects/textblock#recognizerparams):

  * legen Sie den Texttyp mithilfe der Eigenschaft TextTypes des Objekts [RecognizerParams](/de/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/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](/de/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/recognizerparams/setpredefinedtextlanguage-method) fest. Die Verwendung [spezieller vordefinierter Sprachen](/de/fine-reader/engine/specifications/special-predefined-languages) (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](/de/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/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](/de/fine-reader/engine/guided-tour/advanced-techniques/recognizing-checkmarks), [Erkennen handschriftlicher Texte](/de/fine-reader/engine/guided-tour/advanced-techniques/recognizing-handwritten-texts), [Recognizing Barcodes](/de/fine-reader/engine/guided-tour/advanced-techniques/recognizing-barcodes) und [Erkennen von Wörtern mit Leerzeichen](/de/fine-reader/engine/guided-tour/advanced-techniques/recognizing-words-with-spaces).

  ### C\#

  ```csharp theme={null}
  // 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)

  ```cpp theme={null}
  // 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
  ...
  ```
</Accordion>

<Accordion title="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](/de/fine-reader/engine/api-reference/document-related-objects/frdocument/recognize-method), 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\#

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

  ### C++ (COM)

  ```cpp theme={null}
  // Das Dokument erkennen
  // Es müssen keine Parameter angegeben werden, da sie durch das Verarbeitungsprofil festgelegt sind
  frDocument->Recognize( 0, 0 );
  ```
</Accordion>

<Accordion title="Schritt 6. Mit den erkannten Daten arbeiten">
  Verwenden Sie das Objekt [Text](/de/fine-reader/engine/api-reference/text-related-objects/text), um auf das erkannte Textfragment zuzugreifen (Sie können dieses Objekt für einen Textblock über die Eigenschaft [ITextBlock::Text](/de/fine-reader/engine/api-reference/layout-related-objects/textblock#text) abrufen). Verwenden Sie die Eigenschaft Paragraphs, um die Sammlung der Absätze im Fragment abzurufen, und die Methode [IParagraphs::Item](/de/fine-reader/engine/api-reference/text-related-objects/paragraphs), um auf einzelne Absätze zuzugreifen. Die Eigenschaft [IParagraph::Text](/de/fine-reader/engine/api-reference/text-related-objects/paragraph#text) bietet Zugriff auf den erkannten Text eines Absatzes.

  Sie können [IParagraph::Words](/de/fine-reader/engine/api-reference/text-related-objects/paragraph#words) verwenden, um die Wortsammlung eines Absatzes abzurufen. Verwenden Sie die Methode [IWords::Item](/de/fine-reader/engine/api-reference/text-related-objects/words), um auf einzelne Wörter in der Sammlung zuzugreifen. Die Eigenschaft [IWord::Text](/de/fine-reader/engine/api-reference/text-related-objects/word) gibt die Zeile zurück, die das erkannte Wort enthält. Verwenden Sie die Methode [GetRecognitionVariants](/de/fine-reader/engine/api-reference/text-related-objects/word/getrecognitionvariants-method) des Word-Objekts oder die Methode [GetWordRecognitionVariants](/de/fine-reader/engine/api-reference/text-related-objects/paragraph/getwordrecognitionvariants-metho) des Paragraph-Objekts, um die Erkennungsvarianten für ein Wort abzurufen.

  Auf die Attribute einzelner Zeichen kann über die Methode [GetCharParams](/de/fine-reader/engine/api-reference/text-related-objects/paragraph/getcharparams-method) des Paragraph-Objekts zugegriffen werden. Diese Methode bietet Zugriff auf das Objekt [CharParams](/de/fine-reader/engine/api-reference/text-related-objects/charparams), das die Parameter des erkannten Zeichens enthält. Auf die Erkennungsvarianten eines Zeichens kann über die Eigenschaft [ICharParams::CharacterRecognitionVariants](/de/fine-reader/engine/api-reference/text-related-objects/charparams#characterrecognitionvariants) zugegriffen werden.

  Ausführliche Informationen zur Arbeit mit Text finden Sie unter [Arbeiten mit Text](/de/fine-reader/engine/guided-tour/advanced-techniques/working-with-text). Informationen zur Verwendung der Engine in Voting-Algorithmen finden Sie unter [Verwenden der Voting API](/de/fine-reader/engine/guided-tour/advanced-techniques/using-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](/de/fine-reader/engine/api-reference/document-related-objects/frdocument/close-method).
</Accordion>

<Accordion title="Schritt 7. ABBYY FineReader Engine entladen">
  Nachdem Sie die Arbeit mit ABBYY FineReader Engine beendet 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 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)

  ```cpp theme={null}
  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;
  }
  ```
</Accordion>

<div id="required-resources">
  ## Erforderliche Ressourcen
</div>

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 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](/de/fine-reader/engine/guided-tour/advanced-techniques/recognizing-cjk-languages#cjk) erkennen müssen). Weitere Informationen finden Sie unter [Working with the FREngineDistribution.csv File](/de/fine-reader/engine/distribution/distribution-windows/distribution-kit/working-with-the-frenginedistributioncsv-file).

<div id="additional-optimization">
  ## Zusätzliche Optimierung
</div>

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

* Erkennung
  * [Arbeiten mit Sprachen](/de/fine-reader/engine/guided-tour/advanced-techniques/working-with-languages)<br />Verwendung integrierter und benutzerdefinierter Erkennungssprachen.
  * [Arbeiten mit Wörterbüchern](/de/fine-reader/engine/guided-tour/advanced-techniques/working-with-dictionaries)<br />Verwendung von Wörterbüchern zur Verbesserung der Erkennungsqualität.
  * [Erkennen von Wörtern mit Leerzeichen](/de/fine-reader/engine/guided-tour/advanced-techniques/recognizing-words-with-spaces)<br />Verwendung von Wörterbüchern zum Erkennen von Wörtern mit Leerzeichen (z. B. New York).
  * [Erkennen handschriftlicher Texte](/de/fine-reader/engine/guided-tour/advanced-techniques/recognizing-handwritten-texts)<br />Verwendung von ICR (Intelligent Character Recognition).
  * [Erkennen von Häkchen](/de/fine-reader/engine/guided-tour/advanced-techniques/recognizing-checkmarks)<br />Einrichten der Erkennung von Häkchen und Häkchengruppen.
  * [Spezielle vordefinierte Sprachen in ABBYY FineReader Engine](/de/fine-reader/engine/specifications/special-predefined-languages) - Windows<br />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](/de/fine-reader/engine/guided-tour/advanced-techniques/working-with-text)<br />Arbeiten mit erkanntem Text, Absätzen, Wörtern und Zeichen.
  * [Verwenden der Voting API](/de/fine-reader/engine/guided-tour/advanced-techniques/using-voting-api)<br />Arbeiten mit Wörtern und Alternativen der Zeichenerkennung.

<div id="see-also">
  ## Siehe auch
</div>

[Implementierung grundlegender Anwendungsszenarien](/de/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation)