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

# Textextraktion

> Extrahieren Sie den Fließtext eines Dokuments mit ABBYY FineReader Engine in natürlicher Lesereihenfolge, bereit zur Weitergabe an NLP-Engines für Zusammenfassungen, Suche oder Sentimentanalyse.

Dieses Szenario ermöglicht die Extraktion des Fließtexts eines Dokuments sowie von Texten auf Logos, Siegeln und anderen Elementen außerhalb des Fließtexts.

Die natürliche Reihenfolge des Textes – „so, wie ein Mensch ihn lesen würde“ – bleibt erhalten. Anschließend können Sie die Dokumente beispielsweise an Natural-Language-Processing-(NLP-)Engines in Ihren Systemen übergeben, um sie schnell zusammenzufassen, nach sensiblen Informationen zu durchsuchen oder einer Stimmungsanalyse zu unterziehen.

Um den Haupttext eines Dokuments zu extrahieren, durchlaufen Bilddateien, die durch Scannen erstellt oder in einem elektronischen Format gespeichert wurden, in der Regel mehrere Verarbeitungsschritte, von denen jeder seine eigenen Besonderheiten hat:

1. Vorverarbeitung gescannter Bilder oder Fotos

   Gescannten Bildern kann vor der Erkennung eine gewisse Vorverarbeitung erforderlich sein, zum Beispiel wenn gescannte Dokumente Hintergrundrauschen, Text mit Schieflage, invertierte Farben, schwarze Ränder, eine falsche Ausrichtung oder eine ungeeignete Auflösung aufweisen.

2. Erkennung einer möglichst großen Textmenge in einem Dokumentbild

   Die Bilderkennung erfolgt mit Einstellungen, die sicherstellen, dass sämtlicher möglicher Text in einem Dokumentbild gefunden und extrahiert wird.

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

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

Nachfolgend finden Sie eine detaillierte Beschreibung der empfohlenen Vorgehensweise für den Einsatz von ABBYY FineReader Engine 12 in diesem Szenario. Dabei werden Verarbeitungseinstellungen verwendet, die für dieses Szenario am besten geeignet sind.

<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 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](/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 fehlgeschlagen: " + 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 umwandeln
              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
  // sowie 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 für dieses Szenario können in ABBYY FineReader Engine mit der Methode [LoadPredefinedProfile](/de/fine-reader/engine/api-reference/engine-object-iengine-interface/supplementary-methods/loadpredefinedprofile-method) des [Engine](/de/fine-reader/engine/api-reference/engine-object-iengine-interface)-Objekts ausgewählt werden. Diese Methode übernimmt den Profilnamen als Eingabeparameter. Weitere Informationen finden Sie unter [Working with Profiles](/de/fine-reader/engine/guided-tour/advanced-techniques/working-with-profiles).

  ABBYY FineReader Engine unterstützt 2 Einstellungsvarianten für dieses Szenario:

  <table><thead><tr><th><p><strong>Profilname</strong></p></th><th><p><strong>Beschreibung</strong></p></th></tr></thead><tbody><tr><td><p><em>TextExtraction\_Accuracy</em></p></td><td><p>Die Einstellungen wurden auf Genauigkeit optimiert:</p><ul><li>Ermöglicht die Erkennung des gesamten Textes in einem Bild, einschließlich kleiner Textbereiche mit geringer Qualität (Bilder und Tabellen werden nicht erkannt).</li><li>Eine vollständige Synthese der logischen Struktur eines Dokuments wird nicht durchgeführt.</li></ul><Warning>Das Profil ist nicht zum Konvertieren eines Dokuments in RTF, DOCX oder ein reines Text-PDF vorgesehen. Verwenden Sie dafür die Dokumentkonvertierungsprofile.</Warning></td></tr><tr><td><p><em>TextExtraction\_Speed</em></p></td><td><p>Die Einstellungen wurden auf Verarbeitungsgeschwindigkeit optimiert:</p><ul><li>Ermöglicht die Erkennung des gesamten Textes in einem Bild, einschließlich kleiner Textbereiche mit geringer Qualität (Bilder und Tabellen werden nicht erkannt).</li><li>Eine vollständige Synthese der logischen Struktur eines Dokuments wird nicht durchgeführt.</li><li>Die Prozesse der Dokumentanalyse und Erkennung werden beschleunigt.</li></ul><Warning>Das Profil ist nicht zum Konvertieren eines Dokuments in RTF, DOCX oder ein reines Text-PDF vorgesehen. Verwenden Sie dafür die Dokumentkonvertierungsprofile.</Warning></td></tr></tbody></table>

  ### C\#

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

  ### C++ (COM)

  ```cpp theme={null}
  // Ein vordefiniertes Profil laden
  Engine->LoadPredefinedProfile( L"TextExtraction_Accuracy" );
  ```

  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/text-extraction#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) bereit, mit dem mehrseitige Dokumente verarbeitet werden können.

  Um die Bilder eines einzelnen Dokuments zu laden und vorzuverarbeiten, sollten Sie das FRDocument-Objekt erstellen und Bilder hinzufügen. Dazu können Sie wie folgt vorgehen:

  * Erstellen Sie das FRDocument-Objekt mit der Methode [CreateFRDocumentFromImage](/de/fine-reader/engine/api-reference/engine-object-iengine-interface/creation-methods/createfrdocumentfromimage-method) 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](/de/fine-reader/engine/api-reference/engine-object-iengine-interface/creation-methods/createlessobjectgreater-methods) des Engine-Objekts und fügen Sie dann dem erstellten FRDocument-Objekt Bilder aus einer Datei hinzu (verwenden Sie dazu die Methoden [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 FRDocument-Objekts).

  ### 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. Dokumenterkennung">
  Um das Dokument zu erkennen, sollten Sie die Analyse- und Erkennungsmethoden des Objekts [FRDocument](/de/fine-reader/engine/api-reference/document-related-objects/frdocument) verwenden. Dieses Objekt stellt eine ganze Reihe von Methoden für die Dokumentanalyse und -erkennung bereit. Die einfachste Methode, mit der sich Dokumentanalyse, Erkennung und Synthese in einem einzigen Aufruf ausführen lassen, ist die Methode [Process](/de/fine-reader/engine/api-reference/document-related-objects/frdocument/process-method). Sie nutzt außerdem die Funktionen zur parallelen Verarbeitung auf Multiprozessor- und Multicore-Systemen besonders effizient. Sie können jedoch auch die Vorverarbeitung, Analyse, Erkennung und Synthese nacheinander mit den Methoden [Preprocess](/de/fine-reader/engine/api-reference/document-related-objects/frdocument/preprocess-method), [Analyze](/de/fine-reader/engine/api-reference/document-related-objects/frdocument/analyze-method), [Recognize](/de/fine-reader/engine/api-reference/document-related-objects/frdocument/recognize-method) und [Synthesize](/de/fine-reader/engine/api-reference/document-related-objects/frdocument/synthesize-method) durchführen.

  ### C\#

  ```csharp theme={null}
  // Dokument analysieren, erkennen und synthetisieren
  // Zusätzliche Parameter sind nicht erforderlich, da sie im Verarbeitungsprofil festgelegt sind
  frDocument.Process( null );
  ```

  ### C++ (COM)

  ```cpp theme={null}
  // Dokument analysieren, erkennen und synthetisieren
  // Wenn das Profil geladen ist, müssen keine zusätzlichen Parameter an die Verarbeitungsmethode übergeben werden
  frDocument->Process( 0 );
  ```
</Accordion>

<Accordion title="Schritt 5. Suche nach wichtigen Informationen">
  Während der Analyse identifiziert ABBYY FineReader Engine Bildblöcke, die Text, Tabellen, Bilder usw. enthalten. Bei der Erkennung werden die Blöcke mit Textdaten mit dem erkannten Text gefüllt.

  In ABBYY FineReader Engine dient das Objekt [Layout](/de/fine-reader/engine/api-reference/layout-related-objects/layout) zum Speichern von Blöcken und erkanntem Text. Im Hauptszenario der Dokumentverarbeitung wird mit dem Layout innerhalb des Objekts [FRDocument](/de/fine-reader/engine/api-reference/document-related-objects/frdocument) gearbeitet, das das verarbeitete Dokument repräsentiert. Um auf das Layout einer Dokumentseite zuzugreifen, verwenden Sie die Eigenschaft [IFRPage::Layout](/de/fine-reader/engine/api-reference/document-related-objects/frpage).

  Um nach Schlüsselwörtern zu suchen, können Sie den erkannten Text über das Objekt [Text](/de/fine-reader/engine/api-reference/text-related-objects/text) anzeigen, auf das über die Eigenschaften von Text-, Tabellen- oder Barcode-Blöcken zugegriffen werden kann.

  Die wichtigen Daten, die Sie gefunden haben, können je nach Bedarf gespeichert oder verarbeitet werden. Weitere Informationen finden Sie unten unter [Zusätzliche Optimierung für bestimmte Aufgaben](/de/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation/text-extraction#optimization).
</Accordion>

<Accordion title="(Optional) Schritt 6. Dokumentexport">
  Alternativ können Sie den extrahierten Text in einem leicht durchsuchbaren Format wie TXT oder in einem strukturierten Format wie JSON speichern, damit sich benötigte Informationen später einfach abrufen lassen.

  Verwenden Sie die Methode [Export](/de/fine-reader/engine/api-reference/document-related-objects/frdocument/export-method) des Objekts [FRDocument](/de/fine-reader/engine/api-reference/document-related-objects/frdocument) mit einer entsprechenden Konstante aus [FileExportFormatEnum](/de/fine-reader/engine/api-reference/enumerations/fileexportformatenum) als einem der Parameter. Sie können die Standardparameter für den Export mithilfe des entsprechenden Exportobjekts ändern. Weitere Informationen finden Sie unten unter [Zusätzliche Optimierung für bestimmte Aufgaben](/de/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation/document-conversion#optimization).

  Nachdem Sie Ihre Arbeit mit dem Objekt FRDocument abgeschlossen haben, geben Sie alle Ressourcen frei, die von diesem Objekt verwendet wurden. Verwenden Sie die Methode [IFRDocument::Close](/de/fine-reader/engine/api-reference/document-related-objects/frdocument/close-method).

  ### C\#

  ```csharp theme={null}
  // Erkannten Dokumenttext im TXT-Format speichern
  frDocument.Export( "C:\\MyText.txt", FREngine.FileExportFormatEnum.FEF_TextUnicodeDefaults, null );
  // Objekt FRDocument freigeben
  frDocument.Close();
  ```

  ### C++ (COM)

  ```cpp theme={null}
  // Erkannten Dokumenttext im TXT-Format speichern
  frDocument->Export( L"C:\\MyText.txt", FREngine::FEF_TextUnicodeDefaults, 0 );
  // Objekt FRDocument freigeben
  frDocument->Close();
  ```
</Accordion>

<Accordion title="Schritt 7. ABBYY FineReader Engine entladen">
  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 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 Aufräumen 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"Fehler beim Entladen der 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 das Funktionieren 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 [Arbeiten mit der FREngineDistribution.csv-Datei](/de/fine-reader/engine/distribution/distribution-windows/distribution-kit/working-with-the-frenginedistributioncsv-file).

<div id="additional-optimization-for-specific-tasks">
  ## Zusätzliche Optimierung für bestimmte Aufgaben
</div>

* Scannen - nur für Windows
  * [Scannen](/de/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation/scanning)<br />Beschreibung des ABBYY FineReader Engine-Szenarios zum Scannen von Dokumenten.

* Erkennung
  * [Optimierung 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)<br />Anpassung der Dokumentverarbeitung mithilfe von Objekten für Analyse-, Erkennungs- und Syntheseparameter.

* [Handschrift erkennen](/de/fine-reader/engine/guided-tour/advanced-techniques/recognizing-handwritten-texts)<br />Die TextExtraction\_\*\*\*-Profile unterstützen keine Erkennung von handschriftlichem oder handgedrucktem Text. Wenn Sie Handschrift erkennen müssen, setzen Sie die Eigenschaft [DetectHandwritten](/de/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/pageanalysisparams#detecthandwritten) des Objekts [PageAnalysisParams](/de/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/pageanalysisparams) auf TRUE.

* [PageProcessingParams-Objekt](/de/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/pageprocessingparams)<br />Dieses Objekt ermöglicht die Anpassung von Analyse- und Erkennungsparametern. Damit können Sie angeben, welche Bild- und Textmerkmale erkannt werden sollen (invertiertes Bild, Ausrichtung, Barcodes, Erkennungssprache, Fehlertoleranz bei der Erkennung).

* [SynthesisParamsForPage-Objekt](/de/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/synthesisparamsforpage)<br />Dieses Objekt enthält Parameter für die Wiederherstellung der Seitenformatierung während der Synthese.

* [SynthesisParamsForDocument-Objekt](/de/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/synthesisparamsfordocument)<br />Dieses Objekt ermöglicht die Anpassung der Dokumentsynthese: die Wiederherstellung von Struktur und Formatierung.

* [MultiProcessingParams-Objekt](/de/fine-reader/engine/api-reference/parameter-objects/multiprocessingparams) - nur für Linux und Windows<br />Die gleichzeitige Verarbeitung kann bei einer großen Anzahl von Bildern nützlich sein. In diesem Fall wird die Verarbeitungslast beim Öffnen und Vorverarbeiten von Bildern, bei der Layout-Analyse und bei der Erkennung auf die Prozessorkerne verteilt, wodurch sich die Verarbeitung beschleunigen lässt.<br />Die Lesemodi (gleichzeitig oder nacheinander) werden über die Eigenschaft MultiProcessingMode festgelegt. Die Eigenschaft RecognitionProcessesCount steuert die Anzahl der Prozesse, die gestartet werden können.

* Suche nach wichtigen Informationen
  * [Arbeiten mit Layout und Blöcken](/de/fine-reader/engine/guided-tour/advanced-techniques/working-with-layout-and-blocks)<br />Informationen zum Seitenlayout, zu Blocktypen und zur Arbeit damit.
  * [Layout-Objekt](/de/fine-reader/engine/api-reference/layout-related-objects/layout)<br />Die Parameter dieses Objekts bieten Zugriff auf das Seitenlayout und den erkannten Text nach der Dokumenterkennung.
  * [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.

* Erneutes Lesen eines Dokuments mit speziellen Parametern für einen bestimmten Datentyp
  * [Feldbasierte Erkennung](/de/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation/field-level-recognition)<br />Beschreibung des Szenarios zur Erkennung kurzer Textsegmente.

* Speichern von Daten
  * Zum Speichern erkannter Daten können Sie die Methoden [Export](/de/fine-reader/engine/api-reference/document-related-objects/frdocument/export-method) oder [ExportPages](/de/fine-reader/engine/api-reference/document-related-objects/frdocument/exportpages-method) des Objekts [FRDocument](/de/fine-reader/engine/api-reference/document-related-objects/frdocument) verwenden, indem Sie die Konstante [FileExportFormatEnum](/de/fine-reader/engine/api-reference/enumerations/fileexportformatenum) als einen der Parameter angeben.
  * [Dokumentarchivierung](/de/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation/document-archiving)<br />Beschreibung des Szenarios zum Speichern einer elektronischen Kopie eines Dokuments.

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

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