> ## 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. # Archivage de documents > Archivez des documents papier avec ABBYY FineReader Engine : prétraitez les numérisations, exécutez une reconnaissance parallèle et exportez-les au format PDF interrogeable, PDF/A ou PDF compressé avec MRC pour un stockage à long terme. Ce scénario est utilisé pour traiter des documents papier afin de les enregistrer dans une archive numérique, en particulier lors de la création d’archives de contrats, de documentation de projet, de factures, de certificats, etc. Dans ce scénario de traitement, les documents papier sont convertis en copies numériques non modifiables contenant toutes les informations du document dans un format permettant la recherche. À l’issue de ce traitement, les copies numériques des documents peuvent être facilement retrouvées dans une archive électronique à l’aide d’une recherche en texte intégral, des passages du document peuvent être copiés, et les documents peuvent être envoyés par e-mail ou imprimés. Pour créer une copie numérique, le document doit d’abord passer par plusieurs étapes de traitement, chacune présentant ses propres particularités : 1. Prétraitement des images numérisées Les images numérisées peuvent nécessiter un prétraitement avant la reconnaissance, par exemple si les documents numérisés contiennent du bruit de fond, du texte incliné, des couleurs inversées, des marges noires, une orientation incorrecte ou une résolution inadéquate. 2. Reconnaissance simultanée d’un grand nombre de documents Pour extraire des données textuelles d’un document, celui-ci doit être reconnu. Lors du traitement d’un grand nombre de documents, le traitement simultané peut s’avérer utile. Dans ce cas, la charge d’analyse et de reconnaissance peut être répartie entre les cœurs du processeur, ce qui permet d’accélérer le traitement. 3. Exportation vers un format d’archivage Le document reconnu est enregistré dans un format de stockage adapté. Les formats les plus pratiques pour stocker des documents sont PDF, PDF/A, PDF avec MRC et PDF/A avec MRC. Lors de l’enregistrement dans ces formats, il est possible d’utiliser un mode dans lequel le texte est placé sous l’image du document — cela permet de préserver intégralement la mise en forme du document et d’activer la recherche en texte intégral. Les paramètres MRC permettent de réduire considérablement la taille du fichier sans perte de qualité visuelle. En outre, lors de l’enregistrement au format PDF, il est possible de personnaliser les paramètres de sécurité du document afin de le protéger contre toute consultation et impression non autorisées.
## Mise en œuvre du scénario
Les exemples de code fournis dans cette rubrique sont spécifiques à Windows. Vous trouverez ci-dessous une description détaillée de la méthode recommandée pour utiliser ABBYY FineReader Engine 12 afin de créer des copies numériques de documents à des fins d’archivage. La méthode proposée utilise les paramètres de traitement les mieux adaptés à cet usage. Dans cette mise en œuvre, l’étape de numérisation des documents est omise. Veuillez consulter ci-dessous [Optimisation supplémentaire pour des tâches spécifiques](/fr/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation/document-archiving#optimization) pour obtenir des conseils sur la mise en œuvre de la numérisation. Pour commencer à utiliser ABBYY FineReader Engine, vous devez créer l'objet [Engine](/fr/fine-reader/engine/api-reference/engine-object-iengine-interface). L'objet Engine est l'objet de plus haut niveau dans la hiérarchie des objets ABBYY FineReader Engine ; il fournit divers paramètres globaux, certaines méthodes de traitement ainsi que des méthodes permettant de créer les autres objets. Pour créer l'objet Engine, vous pouvez utiliser la fonction [InitializeEngine](/fr/fine-reader/engine/api-reference/functions/initializeengine-function). Voir aussi [les autres façons de charger l'objet Engine](/fr/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() { // Initialisez ces variables avec le chemin complet vers FREngine.dll, votre Customer Project ID, // et, le cas échéant, le chemin vers votre fichier de jeton Online License et le mot de passe Online License string enginePath = ""; string customerProjectId = ""; string licensePath = ""; string licensePassword = ""; // Chargement de la bibliothèque FREngine.dll dllHandle = LoadLibraryEx(enginePath, IntPtr.Zero, LOAD_WITH_ALTERED_SEARCH_PATH); try { if (dllHandle == IntPtr.Zero) { throw new Exception("Impossible de charger " + enginePath); } IntPtr initializeEnginePtr = GetProcAddress(dllHandle, "InitializeEngine"); if (initializeEnginePtr == IntPtr.Zero) { throw new Exception("Impossible de trouver la fonction InitializeEngine"); } IntPtr deinitializeEnginePtr = GetProcAddress(dllHandle, "DeinitializeEngine"); if (deinitializeEnginePtr == IntPtr.Zero) { throw new Exception("Impossible de trouver la fonction DeinitializeEngine"); } IntPtr dllCanUnloadNowPtr = GetProcAddress(dllHandle, "DllCanUnloadNow"); if (dllCanUnloadNowPtr == IntPtr.Zero) { throw new Exception("Impossible de trouver la fonction DllCanUnloadNow"); } // Conversion des pointeurs en délégués initializeEngine = (InitializeEngine)Marshal.GetDelegateForFunctionPointer( initializeEnginePtr, typeof(InitializeEngine)); deinitializeEngine = (DeinitializeEngine)Marshal.GetDelegateForFunctionPointer( deinitializeEnginePtr, typeof(DeinitializeEngine)); dllCanUnloadNow = (DllCanUnloadNow)Marshal.GetDelegateForFunctionPointer( dllCanUnloadNowPtr, typeof(DllCanUnloadNow)); // Appel de la fonction InitializeEngine // en transmettant le chemin vers le fichier Online License et le mot de passe Online License int hresult = initializeEngine(customerProjectId, licensePath, licensePassword, "", "", false, ref engine); Marshal.ThrowExceptionForHR(hresult); } catch (Exception) { // Libération de la bibliothèque FREngine.dll engine = null; // Suppression de tous les objets avant l'appel à FreeLibrary GC.Collect(); GC.WaitForPendingFinalizers(); GC.Collect(); FreeLibrary(dllHandle); dllHandle = IntPtr.Zero; initializeEngine = null; deinitializeEngine = null; dllCanUnloadNow = null; throw; } } // Fonctions 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); // Fonctions FREngine.dll [UnmanagedFunctionPointer(CallingConvention.StdCall, CharSet = CharSet.Unicode)] private delegate int InitializeEngine(string customerProjectId, string licensePath, string licensePassword, string tempFolder, string dataFolder, bool isSharedCPUCoresMode, ref FREngine.IEngine engine); [UnmanagedFunctionPointer(CallingConvention.StdCall)] private delegate int DeinitializeEngine(); [UnmanagedFunctionPointer(CallingConvention.StdCall)] private delegate int DllCanUnloadNow(); // Variables privées private FREngine.IEngine engine = null; // Handle vers FREngine.dll private IntPtr dllHandle = IntPtr.Zero; private InitializeEngine initializeEngine = null; private DeinitializeEngine deinitializeEngine = null; private DllCanUnloadNow dllCanUnloadNow = null; } ``` ### C++ (COM) ```cpp theme={null} // Initialisez ces variables avec le chemin vers FREngine.dll, votre Customer Project ID FineReader Engine, // et, le cas échéant, le chemin vers le jeton Online License et le mot de passe Online License wchar_t* FreDllPath; wchar_t* CustomerProjectId; wchar_t* LicensePath; // si vous n'utilisez pas de Online License, affectez des chaînes vides à ces variables wchar_t* LicensePassword; // Handle vers FREngine.dll static HMODULE libraryHandle = 0; // Objet Engine FineReader Engine global FREngine::IEnginePtr Engine; void LoadFREngine() { if( Engine != 0 ) { // Déjà chargé return; } // Première étape : charger FREngine.dll if( libraryHandle == 0 ) { libraryHandle = LoadLibraryEx( FreDllPath, 0, LOAD_WITH_ALTERED_SEARCH_PATH ); if( libraryHandle == 0 ) { throw L"Erreur lors du chargement d'ABBYY FineReader Engine"; } } // Deuxième étape : obtenir l'objet Engine 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"Erreur lors du chargement d'ABBYY FineReader Engine"; } } ``` ABBYY FineReader Engine permet de charger, à l’aide de la méthode [LoadPredefinedProfile](/fr/fine-reader/engine/api-reference/engine-object-iengine-interface/supplementary-methods/loadpredefinedprofile-method) de l’objet [Engine](/fr/fine-reader/engine/api-reference/engine-object-iengine-interface), tous les paramètres de traitement les mieux adaptés à ce scénario. Cette méthode prend en paramètre d’entrée le nom du profil. Pour plus d’informations, consultez [Working with Profiles](/fr/fine-reader/engine/guided-tour/advanced-techniques/working-with-profiles). ABBYY FineReader Engine prend en charge 2 variantes de paramètres pour ce scénario :

Nom du profil

Description

DocumentArchiving\_Accuracy

Les paramètres ont été optimisés pour la précision :

  • Permet de détecter un maximum de texte dans une image, y compris le texte incorporé à l’image.
  • La synthèse complète de la structure logique d’un document n’est pas effectuée.
Ce profil n’est pas destiné à la conversion d’un document en RTF, DOCX ou PDF texte seul. Utilisez pour cela les profils de conversion de document.

DocumentArchiving\_Speed

Les paramètres ont été optimisés pour la vitesse de traitement :

  • Permet de détecter un maximum de texte dans une image, y compris le texte incorporé à l’image.
  • La correction de l’inclinaison n’est pas effectuée.
  • La synthèse complète de la structure logique d’un document n’est pas effectuée.
  • Les processus d’analyse et de reconnaissance du document sont accélérés.
Ce profil n’est pas destiné à la conversion d’un document en RTF, DOCX ou PDF texte seul. Utilisez pour cela les profils de conversion de document.
### C\# ```csharp theme={null} // Charger un profil prédéfini engine.LoadPredefinedProfile("DocumentArchiving_Accuracy"); ``` ### C++ (COM) ```cpp theme={null} // Charger un profil prédéfini Engine->LoadPredefinedProfile( L"DocumentArchiving_Accuracy" ); ``` Si vous souhaitez modifier les paramètres de traitement, utilisez les objets Parameter appropriés. Pour plus d’informations, consultez [Optimisation supplémentaire pour des tâches spécifiques](/fr/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation/document-archiving#optimization). ABBYY FineReader Engine fournit l’objet [FRDocument](/fr/fine-reader/engine/api-reference/document-related-objects/frdocument), qui permet de traiter des documents multipages. L’utilisation de cet objet permet de préserver l’organisation logique du document. Pour charger les images d’un même document et les prétraiter, vous devez créer l’objet FRDocument et y ajouter des images. Vous pouvez procéder de l’une des manières suivantes : * Créez l’objet FRDocument à l’aide de la méthode [CreateFRDocumentFromImage](/fr/fine-reader/engine/api-reference/engine-object-iengine-interface/creation-methods/createfrdocumentfromimage-method) de l’objet Engine. Cette méthode crée l’objet FRDocument et charge les images à partir du fichier spécifié. * Créez l’objet FRDocument à l’aide de la méthode [CreateFRDocument](/fr/fine-reader/engine/api-reference/engine-object-iengine-interface/creation-methods/createlessobjectgreater-methods) de l’objet Engine, puis ajoutez des images à l’objet FRDocument créé à partir d’un fichier (utilisez la méthode [AddImageFile](/fr/fine-reader/engine/api-reference/document-related-objects/frdocument/addimagefile-method), [AddImageFileWithPassword](/fr/fine-reader/engine/api-reference/document-related-objects/frdocument/addimagefilewithpassword-method) ou [AddImageFileWithPasswordCallback](/fr/fine-reader/engine/api-reference/document-related-objects/frdocument/addimagefilewithpasswordcallback-method) de l’objet FRDocument). ### C\# ```csharp theme={null} // Créer l’objet FRDocument à partir d’un fichier image FREngine.IFRDocument frDocument = engine.CreateFRDocumentFromImage( "C:\\MyImage.tif", null ); ``` ### C++ (COM) ```cpp theme={null} // Créer l’objet FRDocument à partir d’un fichier image FREngine::IFRDocumentPtr frDocument = Engine->CreateFRDocumentFromImage( L"C:\\MyImage.tif", 0 ); ``` Pour reconnaître un document, nous recommandons d’utiliser les méthodes d’analyse et de reconnaissance de l’objet FRDocument. Cet objet fournit toute une série de méthodes pour l’analyse, la reconnaissance et la synthèse du document. La méthode la plus pratique pour effectuer l’analyse, la reconnaissance et la synthèse en un seul appel est la méthode [Process](/fr/fine-reader/engine/api-reference/document-related-objects/frdocument/process-method). Elle exploite également de la manière la plus efficace les fonctionnalités de traitement simultané des systèmes multiprocesseurs et multicœurs. Toutefois, vous pouvez aussi exécuter successivement le prétraitement, l’analyse, la reconnaissance et la synthèse à l’aide des méthodes [Preprocess](/fr/fine-reader/engine/api-reference/document-related-objects/frdocument/preprocess-method), [Analyze](/fr/fine-reader/engine/api-reference/document-related-objects/frdocument/analyze-method), [Recognize](/fr/fine-reader/engine/api-reference/document-related-objects/frdocument/recognize-method) et [Synthesize](/fr/fine-reader/engine/api-reference/document-related-objects/frdocument/synthesize-method). ### C\# ```csharp theme={null} // Analyser, reconnaître et synthétiser le document // Il n'est pas nécessaire de spécifier des paramètres supplémentaires, car ils sont définis par le profil de traitement frDocument.Process( null ); ``` ### C++ (COM) ```cpp theme={null} // Analyser, reconnaître et synthétiser le document // Il n'est pas nécessaire de spécifier des paramètres supplémentaires, car ils sont définis par le profil de traitement frDocument->Process( 0 ); ``` Pour enregistrer un document reconnu, vous pouvez utiliser la méthode [Export](/fr/fine-reader/engine/api-reference/document-related-objects/frdocument/export-method) de l’objet [FRDocument](/fr/fine-reader/engine/api-reference/document-related-objects/frdocument) en passant la constante [FileExportFormatEnum](/fr/fine-reader/engine/api-reference/enumerations/fileexportformatenum) comme l’un des paramètres. Dans ce scénario, vous pouvez par exemple enregistrer le document au format PDF en utilisant MRC avec le mode d’exportation PEM\_ImageOnText (propriété TextExportMode de l’objet [PDFExportParams](/fr/fine-reader/engine/api-reference/parameter-objects/export-parameters/pdfexportparams)). Vous pouvez modifier les paramètres d’exportation par défaut à l’aide de l’objet d’exportation correspondant. Veuillez consulter [Optimisation supplémentaire pour des tâches spécifiques](/fr/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation/document-archiving#optimization) ci-dessous pour plus d’informations. Une fois que vous avez terminé d’utiliser l’objet FRDocument, libérez toutes les ressources employées par cet objet. Utilisez la méthode [IFRDocument::Close](/fr/fine-reader/engine/api-reference/document-related-objects/frdocument/close-method). ### C\# ```csharp theme={null} // Enregistrer un document reconnu dans un format d'archivage (par exemple, PDF) // Créer un objet PDFExportParams FREngine.PDFExportParams exportParams = engine.CreatePDFExportParams(); // Définir les paramètres nécessaires exportParams.MRCMode = FREngine.PDFMRCModeEnum.MRC_Auto; exportParams.TextExportMode = FREngine.PDFExportModeEnum.PEM_ImageOnText; // Utiliser les paramètres lors de l'exportation frDocument.Export( "C:\\MyText.pdf", FREngine.FileExportFormatEnum.FEF_PDF, exportParams ); // Libérer l'objet FRDocument frDocument.Close(); ``` ### C++ (COM) ```cpp theme={null} // Enregistrer un document reconnu dans un format d'archivage (par exemple, PDF) // Créer un objet PDFExportParams FREngine::IPDFExportParamsPtr params = Engine->CreatePDFExportParams(); // Définir les paramètres nécessaires params->MRCMode = FREngine::MRC_Auto; params->TextExportMode = FREngine::PEM_ImageOnText; // Utiliser les paramètres lors de l'exportation frDocument->Export(L"C:\\MyText.pdf", FREngine::FEF_PDF, params); // Libérer l'objet FRDocument frDocument->Close(); ``` Une fois que vous avez terminé d’utiliser ABBYY FineReader Engine, vous devez décharger l’objet [Engine](/fr/fine-reader/engine/api-reference/engine-object-iengine-interface). Pour ce faire, utilisez la fonction exportée [DeinitializeEngine](/fr/fine-reader/engine/api-reference/functions/deinitializeengine-function). ### C\# ```csharp theme={null} public class EngineLoader : IDisposable { // Décharger FineReader Engine public void Dispose() { if (engine == null) { // L’objet Engine n’a pas été chargé return; } engine = null; // Suppression de tous les objets avant l’appel à FreeLibrary 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; // déclencher une exception après le nettoyage Marshal.ThrowExceptionForHR(hresult); } // Fonctions de 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); // Fonctions de 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(); // variables privées private FREngine.IEngine engine = null; // Handle de 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; } // Libérer l’objet Engine Engine = 0; // Désinitialiser FineReader Engine typedef HRESULT ( STDAPICALLTYPE* DeinitializeEngineFunc )(); DeinitializeEngineFunc pDeinitializeEngine = ( DeinitializeEngineFunc )GetProcAddress( libraryHandle, "DeinitializeEngine" ); if( pDeinitializeEngine == 0 || pDeinitializeEngine() != S_OK ) { throw L"Error while unloading ABBYY FineReader Engine"; } // Vous pouvez maintenant libérer la bibliothèque FREngine.dll en toute sécurité FreeLibrary( libraryHandle ); libraryHandle = 0; } ```
## Ressources requises
Vous pouvez utiliser le fichier [FREngineDistribution.csv](/fr/fine-reader/engine/distribution/distribution-windows/distribution-kit/working-with-the-frenginedistributioncsv-file) pour créer automatiquement la liste des fichiers nécessaires au fonctionnement de votre application. Pour le traitement dans ce scénario, sélectionnez dans la colonne 5 (RequiredByModule) les valeurs suivantes : 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 Si vous modifiez le scénario standard, adaptez les modules requis en conséquence. Vous devez également spécifier les langues d’interface, les langues de reconnaissance et toutes les fonctionnalités supplémentaires utilisées par votre application (comme, par exemple, Opening.PDF si vous devez ouvrir des fichiers PDF, ou Processing.OCR.CJK si vous devez reconnaître des textes dans des [langues CJK](/fr/fine-reader/engine/guided-tour/advanced-techniques/recognizing-cjk-languages#cjk)). Consultez [Working with the FREngineDistribution.csv File](/fr/fine-reader/engine/distribution/distribution-windows/distribution-kit/working-with-the-frenginedistributioncsv-file) pour plus de détails.
## Optimisation complémentaire pour certaines tâches
Voici un aperçu des rubriques d’aide contenant des informations supplémentaires sur la personnalisation des paramètres aux différentes étapes du traitement des documents : * Numérisation - Windows uniquement * [Numérisation](/fr/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation/scanning)
Description du scénario d’ABBYY FineReader Engine pour la numérisation de documents. * Reconnaissance * [Réglage des paramètres de prétraitement, d’analyse, de reconnaissance et de synthèse](/fr/fine-reader/engine/guided-tour/advanced-techniques/tuning-parameters-of-preprocessing-analysis-recognition-and-synthesis)
Personnalisation du traitement des documents à l’aide d’objets de paramètres d’analyse, de reconnaissance et de synthèse. * [Reconnaître l’écriture manuscrite](/fr/fine-reader/engine/guided-tour/advanced-techniques/recognizing-handwritten-texts)
Les profils DocumentArchiving\_\*\*\* n’incluent pas la reconnaissance du texte manuscrit ni du texte écrit à la main en lettres moulées. Si vous devez reconnaître de l’écriture manuscrite, définissez la propriété [DetectHandwritten](/fr/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/pageanalysisparams#detecthandwritten) de l’objet [PageAnalysisParams](/fr/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/pageanalysisparams) sur TRUE. * [Objet PageProcessingParams](/fr/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/pageprocessingparams)
Cet objet permet de personnaliser les paramètres d’analyse et de reconnaissance. À l’aide de cet objet, vous pouvez indiquer quelles caractéristiques de l’image et du texte doivent être détectées (image inversée, orientation, codes-barres, langue de reconnaissance, marge d’erreur admise pour la reconnaissance). * [Objet SynthesisParamsForPage](/fr/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/synthesisparamsforpage)
Cet objet inclut les paramètres chargés de restaurer la mise en forme d’une page lors de la synthèse. * [Objet SynthesisParamsForDocument](/fr/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/synthesisparamsfordocument)
Cet objet permet de personnaliser la synthèse du document en restaurant sa structure et sa mise en forme. * [Objet MultiProcessingParams](/fr/fine-reader/engine/api-reference/parameter-objects/multiprocessingparams) - Disponible pour Linux et Windows
Le traitement simultané peut être utile pour traiter un grand nombre d’images. Dans ce cas, la charge de traitement est répartie entre les cœurs du processeur lors de l’ouverture et du prétraitement des images, de l’analyse de la mise en page, de la reconnaissance et de l’exportation, ce qui permet d’accélérer le traitement.
Les modes de lecture (simultané ou consécutif) sont définis à l’aide de la propriété MultiProcessingMode, et la propriété RecognitionProcessesCount contrôle le nombre de processus pouvant être démarrés. * Export * [Réglage des paramètres d’exportation](/fr/fine-reader/engine/guided-tour/advanced-techniques/tuning-export-parameters)
Personnalisation de l’exportation de documents à l’aide d’objets de paramètres d’exportation. * [Objet PDFExportParams](/fr/fine-reader/engine/api-reference/parameter-objects/export-parameters/pdfexportparams)
Cet objet vous permet de configurer l’exportation au format PDF (PDF/A) à l’aide de quelques paramètres seulement. * Pour personnaliser le mode d’exportation au format PDF (PDF/A), utilisez la propriété [TextExportMode](/fr/fine-reader/engine/api-reference/parameter-objects/export-parameters/pdfexportparams#textexportmode) de l’objet PDFExportParams, et pour personnaliser les paramètres MRC, utilisez la propriété [MRCMode](/fr/fine-reader/engine/api-reference/parameter-objects/export-parameters/pdfexportparams#mrcmode). * En outre, vous pouvez personnaliser les paramètres d’exportation des images afin d’accélérer le traitement, de réduire davantage la taille du fichier, etc. Par exemple, vous pouvez enregistrer une image couleur en niveaux de gris ou en noir et blanc, si cela correspond à votre cas d’utilisation (utilisez la propriété [Colority](/fr/fine-reader/engine/api-reference/parameter-objects/export-parameters/pdfexportparams#colority) de l’objet PDFExportParams). * Vous pouvez modifier la résolution de l’image de sorte que la copie électronique obtenue puisse ensuite être imprimée sur une imprimante ou affichée sur un écran d’ordinateur, ou choisir une faible résolution permettant uniquement la lecture du texte et offrant une qualité graphique médiocre (utilisez les propriétés [Resolution](/fr/fine-reader/engine/api-reference/parameter-objects/export-parameters/pdfexportparams#resolution) et [ResolutionType](/fr/fine-reader/engine/api-reference/parameter-objects/export-parameters/pdfexportparams#resolutiontype) de l’objet PDFExportParams). * Découpage en documents * Dans ce scénario, il peut être nécessaire de séparer le lot d’images en plusieurs documents. ABBYY FineReader Engine 12 ne prend pas en charge la séparation automatique des documents. En revanche, vous pouvez utiliser ABBYY FlexiCapture Engine pour mettre en œuvre cette séparation automatique. Les documents peuvent être séparés, par exemple, en fonction du nombre de pages qu’ils contiennent ou à l’aide de pages comportant des codes-barres de séparation. Pour mettre en œuvre une séparation par codes-barres, vous pouvez utiliser le [scénario d’extraction des seules valeurs de codes-barres du document](/fr/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation/barcode-recognition).
## Voir aussi
[Mise en œuvre des scénarios d’utilisation de base](/fr/fine-reader/engine/guided-tour/basic-usage-scenarios-implementation)