Ce scénario sert à extraire toutes les données possibles d’un document et à les stocker de manière structurée.Le résultat est un fichier JSON qui représente la structure du document. Il contient tous les objets du document : texte imprimé et manuscrit, tableaux, codes-barres, cases cochées et images, avec leur emplacement et leurs attributs. Ce format est optimal pour un traitement ultérieur, le stockage des données dans une base de données ou l’intégration à une autre application.Dans ce scénario, un document passe par plusieurs étapes de traitement :
Prétraitement des images numérisées ou des photos
Les images obtenues à l’aide d’un scanner ou d’un appareil photo numérique peuvent nécessiter quelques ajustements avant de pouvoir être reconnues par OCR. Par exemple, les images bruitées ou celles dont les lignes de texte sont déformées doivent être corrigées pour que la reconnaissance optique soit efficace.
Extraction de toutes les données du document de manière structurée
Lors de l’analyse de la mise en page, différents objets sont détectés dans l’image et regroupés en blocs du type correspondant. Les blocs sont reconnus selon les paramètres optimaux pour leur type. Lors de l’étape de synthèse, la structure logique du document est reconstituée de manière cohérente. L’ordre du texte est préservé, même pour les mises en page complexes, de façon à se rapprocher de l’ordre de lecture humain. Cela garantit qu’une nouvelle reconnaissance du même document produira le même ordre de lecture du texte.
Export vers un format structuré
Le document reconnu est enregistré au format JSON ou XML.
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 d’extraire les données des documents. Cette méthode s’appuie sur les paramètres de traitement les mieux adaptés à cet usage.
Étape 1. Chargement d’ABBYY FineReader Engine
Pour commencer à utiliser ABBYY FineReader Engine, vous devez créer l’objet Engine. 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. Consultez également les autres méthodes de chargement de l’objet Engine (Win).
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 de licence en ligne et le mot de passe de la licence en ligne 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 de licence en ligne et le mot de passe de la licence en ligne 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 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, 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;}
// 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 de licence en ligne et le mot de passe de la licence en lignewchar_t* FreDllPath;wchar_t* CustomerProjectId;wchar_t* LicensePath; // si vous n'utilisez pas de licence en ligne, assignez des chaînes vides à ces variableswchar_t* LicensePassword;// HANDLE vers FREngine.dllstatic HMODULE libraryHandle = 0;// Objet Engine FineReader globalFREngine::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 : récupérer 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"; }}
Étape 2. Chargement des paramètres du scénario
ABBYY FineReader Engine permet de charger tous les paramètres de traitement les mieux adaptés à ce scénario à l’aide de la méthode LoadPredefinedProfile de l’objet Engine. Cette méthode prend en entrée le nom du profil. Veuillez consulter Working with Profiles pour plus d’informations.Les paramètres de ce scénario sont disponibles dans le profil prédéfini DataExtraction :
L’analyse de la mise en page et la reconnaissance privilégient la précision plutôt que la vitesse.
Détecte tout le texte d’une image, y compris le texte manuscrit et les petites zones de texte de faible qualité.
Détecte les tableaux, les coches et les codes-barres.
Effectue une synthèse complète de la structure logique d’un document.
// Charger un profil prédéfiniEngine->LoadPredefinedProfile( L"DataExtraction" );
Si vous souhaitez modifier les paramètres de traitement, utilisez les objets Parameter correspondants. Veuillez consulter la section Additional optimization ci-dessous pour plus d’informations.
Étape 3. Chargement et prétraitement des images
ABBYY FineReader Engine fournit l’objet FRDocument, qui permet de traiter des documents multipages. L’utilisation de cet objet vous permet de préserver l’organisation logique du document, en conservant le texte d’origine ainsi que les colonnes, polices, styles, etc.Pour charger et prétraiter les images d’un même document, 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 de l’objet Engine. Cette méthode crée l’objet FRDocument et charge les images à partir du fichier spécifié.
// Créer l’objet FRDocument à partir d’un fichier imageFREngine::IFRDocumentPtr frDocument = Engine->CreateFRDocumentFromImage( L"C:\\MyImage.tif", 0 );
Étape 4. Reconnaissance du document
Pour reconnaître un document, nous vous recommandons d’utiliser les méthodes d’analyse et de reconnaissance de l’objet FRDocument. Cet objet offre toute une série de méthodes pour l’analyse, la reconnaissance et la synthèse de documents. La méthode la plus pratique, qui regroupe en une seule opération l’analyse, la reconnaissance et la synthèse du document, est la méthode Process. 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 effectuer successivement le prétraitement, l’analyse, la reconnaissance et la synthèse à l’aide des méthodes Preprocess, Analyze, Recognize et Synthesize.
// Analyser, reconnaître et synthétiser le document// Il n’est pas nécessaire de fournir de paramètres supplémentaires, car ils sont définis par le profil de traitementfrDocument.Process( null );
// Analyser, reconnaître et synthétiser le document// Il n’est pas nécessaire de fournir de paramètres supplémentaires, car ils sont définis par le profil de traitementfrDocument->Process( 0 );
Étape 5. Exportation du document
Pour enregistrer un document reconnu, vous pouvez utiliser la méthode Export de l’objet FRDocument en passant la constante FileExportFormatEnum comme l’un des paramètres. Vous pouvez modifier les paramètres d’exportation par défaut à l’aide de l’objet d’exportation correspondant. Consultez la section Optimisation supplémentaire pour des tâches spécifiques 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.
// Enregistrer le document reconnu dans un format structuréfrDocument.Export( "C:\\Data.json", FREngine.FileExportFormatEnum.FEF_JSON, null );// Libérer l’objet FRDocumentfrDocument.Close();
// Enregistrer le document reconnu dans un format structuréfrDocument->Export( L"C:\\Data.json", FREngine::FEF_JSON, 0 );// Libérer l’objet FRDocumentfrDocument->Close();
Étape 6. Déchargement d’ABBYY FineReader Engine
Une fois que vous avez terminé d’utiliser ABBYY FineReader Engine, vous devez décharger l’objet Engine. Pour ce faire, utilisez la fonction exportée DeinitializeEngine.
Vous pouvez utiliser le fichier FREngineDistribution.csv pour créer automatiquement la liste des fichiers nécessaires au fonctionnement de votre application. Pour le traitement avec ce scénario, sélectionnez dans la colonne 5 (RequiredByModule) les valeurs suivantes :CoreCore.ResourcesOpeningOpening, ProcessingProcessingProcessing.OCRProcessing.OCR, Processing.ICRProcessing.OCR.NaturalLanguagesProcessing.OCR.NaturalLanguages, Processing.ICR.NaturalLanguagesExportExport, ProcessingSi vous modifiez le scénario standard, adaptez les modules requis en conséquence. Vous devez également spécifier les langues de l’interface utilisateur, 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 les langues CJK). Consultez Working with the FREngineDistribution.csv File pour plus de détails.
Optimisation supplémentaire pour des tâches spécifiques
Vous trouverez ci-dessous un aperçu des rubriques d’aide contenant des informations complémentaires sur la personnalisation des paramètres aux différentes étapes de la conversion d’un document dans un format modifiable :
Numérisation - Windows uniquement
Numérisation Description du scénario ABBYY FineReader Engine pour la numérisation de documents.
PageProcessingParams Object 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, code-barres, langue de reconnaissance, marge d’erreur de reconnaissance).
SynthesisParamsForPage Object Cet objet inclut les paramètres responsables de la restitution de la mise en forme d’une page lors de la synthèse.
SynthesisParamsForDocument Object Cet objet permet de personnaliser la synthèse du document : restitution de sa structure et de sa mise en forme.
MultiProcessingParams Object - Implémenté pour Linux et Windows Le traitement simultané peut être utile lors du traitement d’un grand nombre d’images. Dans ce cas, la charge de traitement est répartie entre les cœurs du processeur pendant l’ouverture et le prétraitement des images, l’analyse de la mise en page, la reconnaissance et l’exportation, ce qui permet d’accélérer le traitement. Les modes de traitement (simultané ou consécutif) sont définis à l’aide de la propriété MultiProcessingMode. La propriété RecognitionProcessesCount contrôle le nombre de processus pouvant être démarrés.
