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

# Datenextraktion

> Extrahieren Sie alle Daten — gedruckten und handschriftlichen Text, Tabellen, Barcodes, Häkchen, Bilder — aus einem Dokument mit ABBYY FineReader Engine und speichern Sie sie als strukturiertes JSON.

Dieses Szenario dient dazu, alle möglichen Daten aus einem Dokument zu extrahieren und strukturiert zu speichern.

Das Ergebnis ist eine JSON-Datei, die die Struktur des Dokuments abbildet. Sie enthält alle Dokumentobjekte: gedruckten und handschriftlich erkannten Text, Tabellen, Barcodes, Häkchen und Bilder mit ihrer Position und ihren Attributen. Dieses Format eignet sich optimal für die Weiterverarbeitung, die Speicherung von Daten in einer Datenbank oder die Integration in eine andere Anwendung.

In diesem Szenario durchläuft ein Dokument mehrere Verarbeitungsschritte:

1. Vorverarbeitung gescannter Bilder oder Fotos

   Bilder, die Sie mit einem Scanner oder einer Digitalkamera erfassen, müssen vor der optischen Erkennung möglicherweise noch nachbearbeitet werden. So müssen beispielsweise verrauschte Bilder oder Bilder mit verzerrten Textzeilen korrigiert werden, damit die optische Erkennung erfolgreich durchgeführt werden kann.

2. Strukturierte Extraktion aller Daten aus dem Dokument

   Bei der Layout-Analyse werden verschiedene Objekte im Bild erkannt und Blöcken des entsprechenden Typs zugeordnet. Die Blöcke werden mit den optimalen Einstellungen für ihren jeweiligen Typ erkannt. Im Zuge der Synthese wird die logische Struktur des Dokuments konsistent wiederhergestellt. Die Reihenfolge des Textes bleibt selbst bei komplexen Layouts so erhalten, dass sie dem menschlichen Leseverhalten entspricht. Dadurch wird sichergestellt, dass eine erneute Erkennung desselben Dokuments zur gleichen Textreihenfolge führt.

3. Export in ein strukturiertes Format

   Das erkannte Dokument wird als JSON oder XML gespeichert.

<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 Datenextraktion aus Dokumenten mit ABBYY FineReader Engine 12. Dabei werden Verarbeitungseinstellungen verwendet, die für diesen Zweck 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 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
  // 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">
  ABBYY FineReader Engine ermöglicht das Laden aller Verarbeitungseinstellungen, die für dieses Szenario am besten geeignet sind, mithilfe 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). Diese Methode verwendet den Profilnamen 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 [DataExtraction](/de/fine-reader/engine/guided-tour/advanced-techniques/working-with-profiles#dataextraction) verfügbar:

  * Layout-Analyse und Erkennung priorisieren Genauigkeit vor Geschwindigkeit.
  * Erkennt den gesamten Text in einem Bild, einschließlich handschriftlichem Text und kleiner Textbereiche von geringer Qualität.
  * Erkennt Tabellen, Häkchen und Barcodes.
  * Die logische Struktur eines Dokuments wird vollständig synthetisiert.

  ### C\#

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

  ### C++ (COM)

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

  Wenn Sie die Verarbeitungseinstellungen ändern möchten, verwenden Sie die entsprechenden Parameterobjekte. Weitere Informationen finden Sie im Abschnitt [Zusätzliche Optimierung](/de/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation/data-extraction#optimization) weiter unten.
</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. Mit diesem Objekt können Sie die logische Struktur des Dokuments beibehalten und dabei den ursprünglichen Text, Spalten, Schriftarten, Stile usw. erhalten.

  Um Bilder eines einzelnen Dokuments zu laden und vorzuverarbeiten, sollten Sie das Objekt FRDocument erstellen und ihm Bilder hinzufügen. Sie können dazu eine der folgenden Möglichkeiten verwenden:

  * Erstellen Sie das Objekt FRDocument mit der Methode [CreateFRDocumentFromImage](/de/fine-reader/engine/api-reference/engine-object-iengine-interface/creation-methods/createfrdocumentfromimage-method) des Objekts Engine. Diese Methode erstellt das Objekt FRDocument und lädt Bilder aus der angegebenen Datei.
  * Erstellen Sie das Objekt FRDocument 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 Bilder aus einer Datei zum erstellten Objekt FRDocument 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}
  // Das FRDocument-Objekt aus einer Bilddatei erstellen
  FREngine::IFRDocumentPtr frDocument = Engine->CreateFRDocumentFromImage( L"C:\\MyImage.tif", 0 );
  ```
</Accordion>

<Accordion title="Schritt 4. Dokumenterkennung">
  Zum Erkennen eines Dokuments empfehlen wir, die Analyse- und Erkennungsmethoden des FRDocument-Objekts zu verwenden. Dieses Objekt bietet eine Vielzahl von Methoden für Dokumentanalyse, Erkennung und Synthese. Die komfortabelste Methode, die Dokumentanalyse, Erkennung und Synthese in einem einzigen Schritt ermöglicht, ist die Methode [Process](/de/fine-reader/engine/api-reference/document-related-objects/frdocument/process-method). Sie nutzt außerdem die Möglichkeiten zur parallelen Verarbeitung auf Multiprozessor- und Multicore-Systemen besonders effizient. Sie können die einzelnen Schritte Vorverarbeitung, Analyse, Erkennung und Synthese jedoch auch 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) ausführen.

  ### C\#

  ```csharp theme={null}
  // Das 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}
  // Das Dokument analysieren, erkennen und synthetisieren
  // Zusätzliche Parameter sind nicht erforderlich, da sie im Verarbeitungsprofil festgelegt sind
  frDocument->Process( 0 );
  ```
</Accordion>

<Accordion title="Schritt 5. Dokumentexport">
  Zum Speichern eines erkannten Dokuments können 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) verwenden, indem Sie die Konstante [FileExportFormatEnum](/de/fine-reader/engine/api-reference/enumerations/fileexportformatenum) als einen der Parameter angeben. Sie können die Standardparameter für den Export über das entsprechende Exportobjekt ändern. Weitere Informationen finden Sie weiter unten unter [Zusätzliche Optimierung für bestimmte Aufgaben](/de/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation/document-conversion#optimization).

  Nachdem Sie die Arbeit mit dem FRDocument-Objekt 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).

  ### C\#

  ```csharp theme={null}
  // Das erkannte Dokument in einem strukturierten Format speichern
  frDocument.Export( "C:\\Data.json", FREngine.FileExportFormatEnum.FEF_JSON, null );
  // Das FRDocument-Objekt freigeben
  frDocument.Close();
  ```

  ### C++ (COM)

  ```cpp theme={null}
  // Das erkannte Dokument in einem strukturierten Format speichern
  frDocument->Export( L"C:\\Data.json", FREngine::FEF_JSON, 0 );
  // Das FRDocument-Objekt freigeben
  frDocument->Close();
  ```
</Accordion>

<Accordion title="Schritt 6. 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;
          // Vor dem Aufruf von FreeLibrary alle Objekte 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;
          // 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 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 den Betrieb Ihrer Anwendung erforderlich sind. Wählen Sie für dieses 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

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 [Working with the FREngineDistribution.csv File](/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>

Nachfolgend finden Sie eine Übersicht über die Hilfethemen mit zusätzlichen Informationen zur Anpassung von Einstellungen in verschiedenen Phasen der Konvertierung von Dokumenten in ein bearbeitbares Format:

* Scannen - *nur unter 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
  * [Parameter für Vorverarbeitung, Analyse, Erkennung und Synthese optimieren](/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.
  * [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 festlegen, welche Bild- und Texteigenschaften 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) - *Implementiert für Linux und Windows* <br />Die gleichzeitige Verarbeitung kann bei der Verarbeitung 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, Erkennung und beim Export auf die Prozessorkerne verteilt, wodurch sich die Verarbeitung beschleunigen lässt.<br />Die Verarbeitungsmodi (simultan oder nacheinander) werden über die Eigenschaft MultiProcessingMode festgelegt. Die Eigenschaft RecognitionProcessesCount steuert die Anzahl der Prozesse, die gestartet werden können.
* Export
  * [Exportparameter optimieren](/de/fine-reader/engine/guided-tour/advanced-techniques/tuning-export-parameters)<br />Anpassung des Dokumentexports mithilfe von Objekten für Exportparameter.
  * [XMLExportParams-Objekt](/de/fine-reader/engine/api-reference/parameter-objects/export-parameters/xmlexportparams)<br />Dieses Objekt stellt die Einstellungen für den Export in das XML-Format bereit.
  * [JsonExportParams-Objekt](/de/fine-reader/engine/api-reference/parameter-objects/export-parameters/jsonexportparams)<br />Dieses Objekt stellt die Einstellungen für den Export in das JSON-Format bereit.

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

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