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

# Dokumentenarchivierung

> Archivieren Sie Papierdokumente mit ABBYY FineReader Engine: Bereiten Sie Scans vor, führen Sie die parallele Erkennung aus und exportieren Sie in durchsuchbares PDF, PDF/A oder MRC-komprimiertes PDF für die Langzeitarchivierung.

Dieses Szenario wird für die Verarbeitung von Papierdokumenten verwendet, um sie in einem digitalen Archiv zu speichern, insbesondere beim Aufbau eines Archivs für Verträge, Projektdokumentationen, Rechnungen, Zertifikate usw.

In diesem Verarbeitungsszenario werden Papierdokumente in nicht bearbeitbare digitale Kopien umgewandelt, die sämtliche Dokumentinformationen in einem durchsuchbaren Format enthalten. Dadurch lassen sich digitale Dokumentkopien in einem elektronischen Archiv per Volltextsuche leicht finden, Textabschnitte aus Dokumenten kopieren sowie Dokumente per E-Mail versenden oder ausdrucken.

Um eine digitale Kopie zu erstellen, muss das Dokument zunächst mehrere Verarbeitungsschritte durchlaufen, von denen jeder seine eigenen Besonderheiten aufweist:

1. Vorverarbeitung gescannter Bilder

   Gescannte Bilder können vor der Erkennung eine gewisse Vorverarbeitung erfordern, zum Beispiel wenn die gescannten Dokumente Hintergrundrauschen, schiefen Text, invertierte Farben, schwarze Ränder, eine falsche Ausrichtung oder eine ungeeignete Auflösung aufweisen.

2. Gleichzeitige Erkennung großer Dokumentenmengen

   Um Textdaten aus einem Dokument zu extrahieren, muss es erkannt werden. Bei der Verarbeitung großer Dokumentenmengen kann die gleichzeitige Verarbeitung mehrerer Dokumente hilfreich sein. In diesem Fall kann die Analyse- und Erkennungslast auf die Prozessorkerne verteilt werden, wodurch sich die Verarbeitung beschleunigen lässt.

3. Export in ein Archivformat

   Das erkannte Dokument wird in einem geeigneten Speicherformat gespeichert. Die praktischsten Formate für die Dokumentenarchivierung sind PDF, PDF/A, PDF und PDF/A mit MRC. Beim Speichern in diesen Formaten kann ein Modus verwendet werden, bei dem der Text unter dem Dokumentbild platziert wird — dadurch bleibt die Dokumentformatierung vollständig erhalten und gleichzeitig wird die Volltextsuche ermöglicht. Mit den MRC-Einstellungen lässt sich die Dateigröße ohne Verlust der visuellen Qualität erheblich reduzieren. Außerdem können beim Speichern im PDF-Format die Sicherheitseinstellungen des Dokuments angepasst werden, um es vor unbefugter Einsicht und unbefugtem Drucken zu schützen.

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

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

Nachfolgend finden Sie eine ausführliche Beschreibung der empfohlenen Methode zur Verwendung von ABBYY FineReader Engine 12, um digitale Kopien von Dokumenten für die Archivierung zu erstellen. Die vorgeschlagene Methode verwendet Verarbeitungseinstellungen, die sich für diesen Zweck am besten eignen. In dieser Implementierung wird auf den Schritt des Dokumentenscannens verzichtet. Hinweise zur Implementierung des Scanvorgangs finden Sie weiter unten unter [Zusätzliche Optimierung für bestimmte Aufgaben](/de/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation/document-archiving#optimization).

<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 Hierarchie der ABBYY FineReader Engine-Objekte und stellt verschiedene globale Einstellungen, einige Verarbeitungsmethoden sowie Methoden zur Erstellung 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
  // 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 erhält 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>DocumentArchiving\_Accuracy</em></p></td><td><p>Die Einstellungen wurden auf Genauigkeit optimiert:</p><ul><li>Ermöglicht die Erkennung einer maximalen Textmenge in einem Bild, einschließlich in das Bild eingebettetem Text.</li><li>Es wird keine vollständige Synthese der logischen Struktur eines Dokuments durchgeführt.</li></ul><Warning>Das Profil ist nicht für die Konvertierung eines Dokuments in RTF, DOCX oder ein reines Text-PDF vorgesehen. Verwenden Sie für diesen Zweck die Dokumentkonvertierungsprofile.</Warning></td></tr><tr><td><p><em>DocumentArchiving\_Speed</em></p></td><td><p>Die Einstellungen wurden auf Verarbeitungsgeschwindigkeit optimiert:</p><ul><li>Ermöglicht die Erkennung einer maximalen Textmenge in einem Bild, einschließlich in das Bild eingebettetem Text.</li><li>Es wird keine Schieflagenkorrektur durchgeführt.</li><li>Es wird keine vollständige Synthese der logischen Struktur eines Dokuments durchgeführt.</li><li>Die Dokumentanalyse und -erkennung werden beschleunigt.</li></ul><Warning>Das Profil ist nicht für die Konvertierung eines Dokuments in RTF, DOCX oder ein reines Text-PDF vorgesehen. Verwenden Sie für diesen Zweck die Dokumentkonvertierungsprofile.</Warning></td></tr></tbody></table>

  ### C\#

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

  ### C++ (COM)

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

  Wenn Sie die Verarbeitungseinstellungen ändern möchten, verwenden Sie die entsprechenden Parameter-Objekte. Weitere Informationen finden Sie unter [Zusätzliche Optimierung für bestimmte Aufgaben](/de/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation/document-archiving#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. Bei Verwendung dieses Objekts bleibt die logische Struktur des Dokuments erhalten.

  Um Bilder eines einzelnen Dokuments zu laden und vorzuverarbeiten, sollten Sie das FRDocument-Objekt erstellen und Bilder hinzufügen. Gehen Sie dazu auf eine der folgenden Arten vor:

  * Erstellen Sie das FRDocument-Objekt mithilfe 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}
  // 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 stellt eine ganze Reihe von Methoden für Dokumentanalyse, Erkennung und Synthese bereit. Die komfortabelste 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 Möglichkeiten zur parallelen Verarbeitung auf Multiprozessor- und Multicore-Systemen besonders effizient. Sie können die 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) durchführen.

  ### C\#

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

  ### C++ (COM)

  ```cpp theme={null}
  // Das Dokument analysieren, erkennen und synthetisieren
  // Zusätzliche Parameter sind nicht erforderlich, da sie durch das Verarbeitungsprofil festgelegt werden
  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. In diesem Szenario können Sie das Dokument beispielsweise im PDF-Format mit MRC im Exportmodus PEM\_ImageOnText speichern (Eigenschaft TextExportMode des Objekts [PDFExportParams](/de/fine-reader/engine/api-reference/parameter-objects/export-parameters/pdfexportparams)). Sie können die Standard-Exportparameter über das entsprechende Exportobjekt ä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-archiving#optimization).

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

  ### C\#

  ```csharp theme={null}
  // Ein erkanntes Dokument in einem Archivformat speichern (zum Beispiel PDF)
  // Ein PDFExportParams-Objekt erstellen
  FREngine.PDFExportParams exportParams = engine.CreatePDFExportParams();
  // Die erforderlichen Parameter festlegen
  exportParams.MRCMode = FREngine.PDFMRCModeEnum.MRC_Auto;
  exportParams.TextExportMode = FREngine.PDFExportModeEnum.PEM_ImageOnText;
  // Die Parameter beim Export verwenden
  frDocument.Export( "C:\\MyText.pdf", FREngine.FileExportFormatEnum.FEF_PDF, exportParams );
  // Das FRDocument-Objekt freigeben
  frDocument.Close();
  ```

  ### C++ (COM)

  ```cpp theme={null}
  // Ein erkanntes Dokument in einem Archivformat speichern (z. B. PDF)
  // Ein PDFExportParams-Objekt erstellen
  FREngine::IPDFExportParamsPtr params = Engine->CreatePDFExportParams();
  // Die erforderlichen Parameter festlegen
  params->MRCMode = FREngine::MRC_Auto;
  params->TextExportMode = FREngine::PEM_ImageOnText;
  // Die Parameter beim Export verwenden
  frDocument->Export(L"C:\\MyText.pdf", FREngine::FEF_PDF, params);
  // 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;
          // 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"Fehler beim Entladen von 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 Ihre Anwendung zum Funktionieren benötigt. 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

Export

Export, Processing

Export.Pdf

Export.Pdf, Opening.Pdf

Wenn Sie das Standardszenario ändern, passen Sie die erforderlichen Module entsprechend an. Außerdem müssen Sie 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 Dokumentverarbeitung:

* 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
  * [Feinabstimmung 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.

* [Handschriftliche Texte erkennen](/de/fine-reader/engine/guided-tour/advanced-techniques/recognizing-handwritten-texts)<br />Die DocumentArchiving\_\*\*\*-Profile unterstützen keine Erkennung von handschriftlichem oder in Druckbuchstaben geschriebenem 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. Mit diesem Objekt 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 bei 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 nützlich sein, wenn eine große Anzahl von Bildern verarbeitet werden muss. In diesem Fall wird die Verarbeitungslast beim Öffnen und Vorverarbeiten von Bildern, bei der Layout-Analyse, der Erkennung und beim Export auf die Prozessorkerne verteilt, wodurch sich die Verarbeitung beschleunigen lässt.<br />Die Verarbeitungsmodi (gleichzeitig oder nacheinander) werden über die Eigenschaft MultiProcessingMode festgelegt, und 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 />Anpassen des Dokumentexports mithilfe von Exportparameterobjekten.
  * [PDFExportParams-Objekt](/de/fine-reader/engine/api-reference/parameter-objects/export-parameters/pdfexportparams)<br />Mit diesem Objekt können Sie den Export in PDF (PDF/A) mit nur wenigen Parametern konfigurieren.
  * Um den Exportmodus für das PDF-Format (PDF/A) anzupassen, verwenden Sie die Eigenschaft [TextExportMode](/de/fine-reader/engine/api-reference/parameter-objects/export-parameters/pdfexportparams#textexportmode) des PDFExportParams-Objekts. Um die MRC-Einstellungen anzupassen, verwenden Sie die Eigenschaft [MRCMode](/de/fine-reader/engine/api-reference/parameter-objects/export-parameters/pdfexportparams#mrcmode).
  * Darüber hinaus können Sie die Einstellungen für den Bildexport anpassen, um eine schnellere Verarbeitung, eine weitere Reduzierung der Dateigröße usw. zu erzielen. So können Sie beispielsweise ein Farbbild als Graustufen- oder Schwarzweißbild speichern, wenn dies für Ihren Anwendungsfall geeignet ist (verwenden Sie die Eigenschaft [Colority](/de/fine-reader/engine/api-reference/parameter-objects/export-parameters/pdfexportparams#colority) des PDFExportParams-Objekts).
  * Sie können die Bildauflösung so ändern, dass die erzeugte elektronische Kopie anschließend auf einem Drucker ausgedruckt oder auf einem Computerbildschirm angezeigt werden kann. Alternativ können Sie eine niedrige Auflösung wählen, die nur das Lesen von Text ermöglicht und eine sehr geringe Grafikqualität bietet (verwenden Sie die Eigenschaft [Resolution](/de/fine-reader/engine/api-reference/parameter-objects/export-parameters/pdfexportparams#resolution) und [ResolutionType](/de/fine-reader/engine/api-reference/parameter-objects/export-parameters/pdfexportparams#resolutiontype) des PDFExportParams-Objekts).

* Aufteilung in Dokumente
  * In diesem Szenario muss der Stapel von Bildern möglicherweise in einzelne Dokumente aufgeteilt werden. ABBYY FineReader Engine 12 unterstützt keine automatische Dokumenttrennung. Sie können jedoch ABBYY FlexiCapture Engine verwenden, um eine automatische Trennung zu implementieren. Die Dokumente können beispielsweise anhand der Seitenanzahl pro Dokument oder anhand von Seiten mit Trenn-Barcodes getrennt werden. Wenn Sie die Trennung per Barcode implementieren, können Sie das [Szenario zur Extraktion von Barcode-Werten nur aus dem Dokument](/de/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation/barcode-recognition) verwenden.

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

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