> ## 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.
# Utilisation des dictionnaires
> Associez des dictionnaires standard, utilisateur, à expression régulière ou agrégés à une langue de reconnaissance ABBYY FineReader Engine afin d’améliorer la précision de l’OCR sur des textes spécifiques à un domaine.
Les exemples en C# s’appliquent uniquement à FRE pour Windows.
ABBYY FineReader Engine vous permet d’associer à une langue de reconnaissance des dictionnaires de différents types, ce qui améliore considérablement la qualité de la reconnaissance.
## Types de dictionnaires
Les dictionnaires peuvent être de plusieurs types :
Ce type de dictionnaire est déjà fourni pour les langues prédéfinies qui disposent d’une prise en charge intégrée des dictionnaires (voir les commentaires dans la [liste des langues prédéfinies](/fr/fine-reader/engine/specifications/predefined-languages)). En outre, pour certaines langues, il existe des dictionnaires de termes spécialisés (par ex. médicaux et juridiques) regroupés dans l’archive .zmd. Les dictionnaires standard sont représentés par trois ou quatre fichiers. Leurs noms correspondent généralement au nom complet ou abrégé de la langue et ont une extension .amd, .amm, .amt ou .ame. Les fichiers portant les extensions .amd, .amm et .amt sont toujours présents. Ils sont stockés dans les dossiers suivants et ne peuvent pas être modifiés : [Data/ExtendedDictionaries](/fr/fine-reader/engine/distribution/distribution-windows/distribution-kit#dictionaries) (Linux), [Resources/ExtendedDictionaries](/fr/fine-reader/engine/distribution/distribution-windows/distribution-kit#dictionaries) (macOS), [Data\ExtendedDictionaries](/fr/fine-reader/engine/distribution/distribution-windows/distribution-kit#dictionaries) (Windows).
Aucun fichier .ame n’est fourni avec ABBYY FineReader Engine : il s’agit d’un format servant à stocker une extension de dictionnaire, c’est-à-dire les mots ajoutés au dictionnaire par l’utilisateur. Vous pouvez créer une extension de dictionnaire dans ABBYY FineReader, où elle est appelée dictionnaire utilisateur, puis copier le fichier créé dans le dossier mentionné ci-dessus, sous le dossier ABBYY FineReader Engine (ou en spécifier le chemin d’accès complet dans la propriété [ILanguageDatabase::DictionaryExtensionsPath](/fr/fine-reader/engine/api-reference/language-related-objects/languagedatabase#dictionaryextensionspath)). ABBYY FineReader stocke les extensions des dictionnaires standard dans %appdata%\ABBYY\FineReader\15\FineReaderShell\UserDictionaries. Les extensions de dictionnaire peuvent être modifiées dans ABBYY FineReader Engine à l’aide de la méthode [ILanguageDatabase::OpenDictionaryExtension](/fr/fine-reader/engine/api-reference/language-related-objects/languagedatabase/opendictionaryextension-method).
Ce type de dictionnaire est décrit par l’objet [StandardDictionaryDescription](/fr/fine-reader/engine/api-reference/language-related-objects/standarddictionarydescription).
Peut être créé à l’aide de l’objet [Dictionary](/fr/fine-reader/engine/api-reference/language-related-objects/dictionary). L’objet Dictionary vous permet d’ajouter et de supprimer des mots à l’aide de ses méthodes.
Sous Windows, l’objet Dictionary vous permet également de modifier le dictionnaire à l’aide de la [boîte de dialogue Dictionary](/fr/fine-reader/engine/api-reference/language-related-objects/dictionary/edit-method/dictionary-dialog-box). Cette boîte de dialogue vous permet d’importer n’importe quel fichier texte encodé en Windows ANSI ou en Unicode (la seule exigence étant que les mots soient séparés par des espaces ou d’autres caractères non alphabétiques).
Ce type de dictionnaire est décrit par l’objet [UserDictionaryDescription](/fr/fine-reader/engine/api-reference/language-related-objects/userdictionarydescription).
Dans FineReader Engine, le dictionnaire utilisateur utilise le format de fichier .amd et peut être créé pour n’importe quelle langue. Il peut remplacer le dictionnaire standard pour les langues qui ne disposent pas d’une prise en charge des dictionnaires. Dans FineReader Engine, le dictionnaire utilisateur d’ABBYY FineReader est appelé extension de dictionnaire ; il s’agit d’un fichier .ame qui ne peut être créé que pour les langues prenant en charge les dictionnaires, comme extension du dictionnaire standard de cette langue.
Spécifie les règles qui définissent quels mots sont autorisés dans une langue et quels mots ne le sont pas.
Ce type de dictionnaire est décrit par l’objet [RegExpDictionaryDescription](/fr/fine-reader/engine/api-reference/language-related-objects/regexpdictionarydescription).
Vous permet d’implémenter votre propre type de dictionnaire. Ce dictionnaire est représenté par l’interface [IExternalDictionary](/fr/fine-reader/engine/api-reference/language-related-objects/iexternaldictionary-interface), qui est implémentée côté client. Vous trouverez dans la description de cette interface des recommandations pour créer un dictionnaire externe.
Ce type de dictionnaire est décrit par l’objet [ExternalDictionaryDescription](/fr/fine-reader/engine/api-reference/language-related-objects/externaldictionarydescription).
ABBYY FineReader Engine fournit un objet [DictionaryDescription](/fr/fine-reader/engine/api-reference/language-related-objects/dictionarydescription) pour décrire tous les types de dictionnaires. Il s’agit de l’objet de base dont héritent les descriptions des différents types de dictionnaires.
Toutes ces descriptions de dictionnaires sont des éléments de la collection [DictionaryDescriptions](/fr/fine-reader/engine/api-reference/language-related-objects/dictionarydescriptions).
## Création d'une description de dictionnaire
Pour créer des descriptions de dictionnaires, utilisez la méthode [AddNew](/fr/fine-reader/engine/api-reference/language-related-objects/dictionarydescriptions/addnew-method) de l’objet DictionaryDescriptions. Cette méthode renvoie une référence à l’objet DictionaryDescription. Pour obtenir une référence à l’objet qui décrit le type de dictionnaire correspondant, utilisez les méthodes [GetAsStandardDictionaryDescription](/fr/fine-reader/engine/api-reference/language-related-objects/dictionarydescription/getasstandarddictionarydescription-method), [GetAsUserDictionaryDescription](/fr/fine-reader/engine/api-reference/language-related-objects/dictionarydescription/getasuserdictionarydescription-method), [GetAsRegExpDictionaryDescription](/fr/fine-reader/engine/api-reference/language-related-objects/dictionarydescription/getasregexpdictionarydescription-method) et [GetAsExternalDictionaryDescription](/fr/fine-reader/engine/api-reference/language-related-objects/dictionarydescription/getasexternaldictionarydescription-method) de l’objet DictionaryDescription.
## Propriétés des dictionnaires
Pour chaque dictionnaire, la propriété d’identification correspondante doit être spécifiée :
* Pour un dictionnaire standard (StandardDictionaryDescription), spécifiez sa propriété LanguageId, qui définit l’ID de la langue.
* Pour un dictionnaire utilisateur (UserDictionaryDescription), spécifiez sa propriété FileName, qui indique le chemin du dictionnaire utilisateur.
* Pour un dictionnaire basé sur des expressions régulières (RegExpDictionaryDescription), utilisez la méthode [SetText](/fr/fine-reader/engine/api-reference/language-related-objects/regexpdictionarydescription/settext-method) pour spécifier l’expression régulière. Voir [Utilisation des expressions régulières dans ABBYY FineReader Engine](/fr/fine-reader/engine/guided-tour/advanced-techniques/working-with-regular-expressions).
* Pour un dictionnaire externe (ExternalDictionaryDescription), utilisez la méthode [SetDictionary](/fr/fine-reader/engine/api-reference/language-related-objects/externaldictionarydescription/setdictionary-method) pour spécifier le dictionnaire.
Un poids est attribué à tous les types de dictionnaires. Le poids d’un dictionnaire influe sur celui des mots provenant de ce dictionnaire lorsqu’ils sont détectés lors de la reconnaissance. Le paramètre de poids est exprimé en pourcentage et doit être positif ou nul. Un poids de 0 ne signifie pas automatiquement qu’il n’existe pas de dictionnaire de ce type. Des poids supérieurs à 100 % sont autorisés, mais l’utilisateur doit faire preuve d’une grande prudence lorsqu’il utilise de tels paramètres. Le poids est spécifié dans la propriété [IDictionaryDescription::Weight](/fr/fine-reader/engine/api-reference/language-related-objects/dictionarydescription#weight) et sa valeur par défaut est 100.
Les dictionnaires standard disposent également d’une option [CanUseTrigrams](/fr/fine-reader/engine/api-reference/language-related-objects/standarddictionarydescription#canusetrigrams) qui autorise ou interdit au programme d’utiliser des trigrammes construits à partir du dictionnaire sélectionné. Les trigrammes sont des combinaisons de trois lettres. Toutes ces combinaisons n’apparaissent pas dans des mots réels. Un mot contenant un trigramme absent du dictionnaire a de fortes chances d’être imprononçable. Les trigrammes servent à écarter les mots peu fiables. Nous recommandons d’activer les trigrammes pour les dictionnaires standard « généraux » et de les désactiver pour les dictionnaires de termes.
## Dictionnaires d’une langue de reconnaissance
Une langue de reconnaissance de texte (l’objet [TextLanguage](/fr/fine-reader/engine/api-reference/language-related-objects/textlanguage)) peut comporter à la fois des dictionnaires contenant des mots de la langue et des dictionnaires de mots interdits. Les premiers sont définis pour chaque [langue de reconnaissance de base](/fr/fine-reader/engine/api-reference/language-related-objects/baselanguage) de la langue de texte et sont accessibles via la propriété [IBaseLanguage::DictionaryDescriptions](/fr/fine-reader/engine/api-reference/language-related-objects/baselanguage#dictionarydescriptions). Une langue de base peut ne pas avoir de dictionnaire associé. Les dictionnaires de mots interdits sont associés directement à la langue de reconnaissance de texte via la propriété [ITextLanguage::ProhibitingDictionaries](/fr/fine-reader/engine/api-reference/language-related-objects/textlanguage#prohibitingdictionaries).
Si vous souhaitez que seuls les mots du dictionnaire soient autorisés lors de la reconnaissance, définissez la propriété [IBaseLanguage::AllowWordsFromDictionaryOnly](/fr/fine-reader/engine/api-reference/language-related-objects/baselanguage#allowwordsfromdictionaryonly) sur TRUE. Dans ce cas, un mot absent du dictionnaire de la langue de base ne peut apparaître dans le texte reconnu que si ABBYY FineReader Engine n’a trouvé aucune variante dans le dictionnaire.
## Comment associer un dictionnaire à une langue de reconnaissance
1. Créez un objet [TextLanguage](/fr/fine-reader/engine/api-reference/language-related-objects/textlanguage) à l’aide de l’une des méthodes disponibles (par exemple, la méthode [CreateTextLanguage](/fr/fine-reader/engine/api-reference/language-related-objects/languagedatabase/createtextlanguage-method) de l’objet [LanguageDatabase](/fr/fine-reader/engine/api-reference/language-related-objects/languagedatabase)).
2. Récupérez la collection des langues de base de la nouvelle langue de texte (utilisez la propriété [BaseLanguages](/fr/fine-reader/engine/api-reference/language-related-objects/textlanguage#baselanguages)).
3. Créez un nouvel objet [BaseLanguage](/fr/fine-reader/engine/api-reference/language-related-objects/baselanguage) et ajoutez-le à la collection des langues de base.
4. Récupérez la collection des descriptions de dictionnaire de la nouvelle langue de base (propriété [DictionaryDescriptions](/fr/fine-reader/engine/api-reference/language-related-objects/baselanguage#dictionarydescriptions)).
5. Créez une description de dictionnaire et ajoutez-la à la collection des descriptions de dictionnaire de la langue de base. Utilisez la méthode [AddNew](/fr/fine-reader/engine/api-reference/language-related-objects/dictionarydescriptions/addnew-method) de la collection [DictionaryDescriptions](/fr/fine-reader/engine/api-reference/language-related-objects/dictionarydescriptions).
Vous pouvez créer plusieurs dictionnaires de types différents et les ajouter à la collection [DictionaryDescriptions](/fr/fine-reader/engine/api-reference/language-related-objects/dictionarydescriptions) d’une même langue de reconnaissance de base.
6. \[Facultatif] Spécifiez le poids du dictionnaire créé.
7. Spécifiez la propriété d’identification du dictionnaire : la propriété LanguageId pour un dictionnaire standard, la propriété FileName pour un dictionnaire utilisateur, appelez la méthode IRegExpDictionaryDescription::SetText pour un dictionnaire basé sur des expressions régulières, ou la méthode IExternalDictionaryDescription::SetDictionary pour un dictionnaire externe.
8. \[Facultatif] Spécifiez d’autres propriétés de l’objet [BaseLanguage](/fr/fine-reader/engine/api-reference/language-related-objects/baselanguage).
9. \[Facultatif] Définissez les dictionnaires de mots interdits à l’aide de la propriété ProhibitingDictionaries de l’objet [TextLanguage](/fr/fine-reader/engine/api-reference/language-related-objects/textlanguage).
10. Affectez l’objet [TextLanguage](/fr/fine-reader/engine/api-reference/language-related-objects/textlanguage) créé à la propriété TextLanguage de l’objet [RecognizerParams](/fr/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/recognizerparams).
Pour implémenter ces étapes sous Windows, consultez les exemples de code ci-dessous.
```cpp theme={null}
// Objet global ABBYY FineReader Engine
FREngine::IEnginePtr Engine;
// Un objet LanguageDatabase
FREngine::ILanguageDatabasePtr languageDatabase;
...
// Créez un objet TextLanguage et récupérez sa collection de langues de base
FREngine::ITextLanguagePtr pTextLang = languageDatabase->CreateTextLanguage();
FREngine::IBaseLanguagesPtr pBaseLangCollection = pTextLang->BaseLanguages;
// Créez un objet BaseLanguage et récupérez sa collection de descriptions de dictionnaire
FREngine::IBaseLanguagePtr pBaseLang = pBaseLangCollection->AddNew();
pBaseLang->InternalName = L"SampleBaseLanguage";
pBaseLang->PutLetterSet( FREngine::BLLS_Alphabet, L"abc123" );
FREngine::IDictionaryDescriptionsPtr pDictDescCollection = pBaseLang->DictionaryDescriptions;
// Créez une description de dictionnaire standard et ajoutez-la à la collection
FREngine::IDictionaryDescriptionPtr pDicDescription =
pDictDescCollection->AddNew( FREngine::DT_SystemDictionary);
// [facultatif] Spécifiez le poids du dictionnaire créé
pDicDescription->Weight = 100;
// Spécifiez la propriété d’identification du dictionnaire
FREngine::IStandardDictionaryDescriptionPtr pStandardDic = pDicDescription->GetAsStandardDictionaryDescription();
pStandardDic->LanguageId = FREngine::LI_EnglishUnitedStates;
// [facultatif] Spécifiez d’autres propriétés de l’objet BaseLanguage
pBaseLang->AllowWordsFromDictionaryOnly = VARIANT_TRUE;
// Créez un objet RecognizerParams
FREngine::IRecognizerParamsPtr pParams = Engine->CreateRecognizerParams();
// Affectez l’objet TextLanguage créé à la propriété TextLanguage
pParams->TextLanguage = pTextLang;
...
```
```csharp theme={null}
// Objet ABBYY FineReader Engine global
FREngine.IEngine engine;
// Objet LanguageDatabase
FREngine.ILanguageDatabase languageDatabase;
...
// Créer un objet TextLanguage et récupérer sa collection de langues de base
FREngine.ITextLanguage TextLang = languageDatabase.CreateTextLanguage();
FREngine.IBaseLanguages BaseLangCollection = TextLang.BaseLanguages;
// Créer un objet BaseLanguage et récupérer sa collection de descriptions de dictionnaire
FREngine.IBaseLanguage BaseLang = BaseLangCollection.AddNew();
BaseLang.InternalName = "SampleBaseLanguage";
BaseLang.set_LetterSet( FREngine.BaseLanguageLetterSetEnum.BLLS_Alphabet, "abc123" );
FREngine.IDictionaryDescriptions DictDescCollection = BaseLang.DictionaryDescriptions;
// Créer une description de dictionnaire standard et l'ajouter à la collection
FREngine.IDictionaryDescription DicDescription = DictDescCollection.AddNew( FREngine.DictionaryTypeEnum.DT_SystemDictionary );
// [facultatif] Indiquer le poids du dictionnaire créé
DicDescription.Weight = 100;
// Indiquer la propriété d'identification du dictionnaire
FREngine.IStandardDictionaryDescription StandardDic = DicDescription.GetAsStandardDictionaryDescription();
StandardDic.LanguageId = FREngine.LanguageIdEnum.LI_EnglishUnitedStates;
// [facultatif] Indiquer d'autres propriétés de la langue de base BaseLanguage
BaseLang.AllowWordsFromDictionaryOnly = true;
// Créer un objet RecognizerParams
FREngine.IRecognizerParams recParams = engine.CreateRecognizerParams();
// Affecter l'objet TextLanguage créé à la propriété TextLanguage
recParams.TextLanguage = TextLang;
...
```
## Dictionnaire cache
Un dictionnaire cache est un petit dictionnaire (d’environ une centaine de mots) qui peut être facilement modifié pendant le traitement. Les dictionnaires cache peuvent être utilisés lorsqu’il est possible de sélectionner un dictionnaire de manière plus précise, par exemple si vous obtenez de nouvelles informations sur le document en cours de traitement. Ces dictionnaires conviennent à la reconnaissance au niveau du champ.
Par exemple, supposons qu’un formulaire comporte deux champs à reconnaître : le nom d’une ville et le nom d’une rue. Vous avez reconnu le nom de la ville et vous disposez de la liste des rues de cette ville. Dans ce cas, vous pouvez charger dans le dictionnaire cache approprié les noms de rues, puis reconnaître le nom de la rue plus rapidement et avec plus de précision.
ABBYY FineReader Engine fournit les méthodes [AddWordsToCacheDictionary](/fr/fine-reader/engine/api-reference/document-related-objects/frpage/addwordstocachedictionary-method), [AddWordToCacheDictionary](/fr/fine-reader/engine/api-reference/document-related-objects/frpage/addwordtocachedictionary-method) et [CleanCacheDictionary](/fr/fine-reader/engine/api-reference/document-related-objects/frpage/cleancachedictionary-method) de l’objet [FRPage](/fr/fine-reader/engine/api-reference/document-related-objects/frpage) pour travailler avec les dictionnaires cache.
Pour utiliser le dictionnaire cache, vous devez définir la propriété [IEngine::AutoCleanRecognizerSession](/fr/fine-reader/engine/api-reference/engine-object-iengine-interface/properties#autocleanrecognizersession) sur FALSE. La propriété AutoCleanRecognizerSession est définie sur TRUE par défaut, ce qui signifie que FineReader Engine efface sa session de reconnaissance après la reconnaissance de chaque page ; dans ce cas, le dictionnaire cache est lui aussi effacé. Pour éviter toute suppression accidentelle des données utilisateur, FineReader Engine interdit l’utilisation des dictionnaires cache dans ce mode. Si vous utilisez le dictionnaire cache, c’est à vous de nettoyer manuellement la session de reconnaissance en appelant la méthode [IEngine::CleanRecognizerSession](/fr/fine-reader/engine/api-reference/engine-object-iengine-interface/supplementary-methods/cleanrecognizersession-method) lorsque nécessaire. Consultez la description de la méthode pour savoir à quel moment il est nécessaire de nettoyer la session de reconnaissance.
## Voir aussi
[Travailler avec les langues](/fr/fine-reader/engine/guided-tour/advanced-techniques/working-with-languages)
[Reconnaître les mots contenant des espaces](/fr/fine-reader/engine/guided-tour/advanced-techniques/recognizing-words-with-spaces)