> ## 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 de l’API Voting

> Utilisez l’API Voting d’ABBYY FineReader Engine pour accéder aux hypothèses de reconnaissance de caractères et de mots (WordRecognitionVariants, CharacterRecognitionVariants) avec leurs niveaux de confiance.

Les développeurs peuvent combiner plusieurs Engines dans leurs solutions de reconnaissance. Lorsque plusieurs Engines génèrent différentes variantes de reconnaissance pour un caractère ou un mot, le développeur peut sélectionner la meilleure variante par vote entre ces variantes. Pour activer le vote, ABBYY FineReader Engine dispose d’une API Voting dédiée qui donne accès à différentes hypothèses de reconnaissance de caractères ou de mots, avec les valeurs de pondération correspondantes. En plus du vote, le développeur peut utiliser l’API Voting pour vérifier les résultats de reconnaissance à l’aide de ses propres bases de données et algorithmes, ainsi que pour corriger le texte. Par exemple, le développeur peut former des mots à partir de lettres ou vérifier toutes les hypothèses générées.

<Warning>
  L’API Voting n’est pas disponible pour la reconnaissance de textes manuscrits ou tracés à la main en lettres détachées.
</Warning>

L’objet [WordRecognitionVariants](/fr/fine-reader/engine/api-reference/text-related-objects/wordrecognitionvariants) représente une collection d’hypothèses pour un mot, et l’objet [CharacterRecognitionVariants](/fr/fine-reader/engine/api-reference/text-related-objects/characterrecognitionvariants) représente une collection d’hypothèses pour un caractère. Les éléments de ces collections sont respectivement les objets [WordRecognitionVariant](/fr/fine-reader/engine/api-reference/text-related-objects/wordrecognitionvariant) et [CharacterRecognitionVariant](/fr/fine-reader/engine/api-reference/text-related-objects/characterrecognitionvariant).

L’objet WordRecognitionVariant représente une seule hypothèse pour un mot et contient le texte de l’hypothèse, le type de modèle, l’épaisseur moyenne du trait et des informations indiquant si l’hypothèse a été trouvée dans le dictionnaire. La méthode [GetCharParams](/fr/fine-reader/engine/api-reference/text-related-objects/wordrecognitionvariant/getcharparams-method) de cet objet donne accès aux paramètres d’un seul caractère.

L’objet CharacterRecognitionVariant représente une seule hypothèse pour un caractère et contient le niveau de confiance du caractère, la probabilité qu’un caractère soit écrit avec une police à empattement et des informations indiquant si le caractère est en exposant ou en indice.

<div id="how-to-retrieve-recognition-variants-for-a-word-or-character">
  ## Comment récupérer les variantes de reconnaissance d’un mot ou d’un caractère
</div>

Si vous souhaitez obtenir toutes les hypothèses de reconnaissance pour un mot ou un caractère, procédez comme suit :

1. Définissez sur TRUE les propriétés SaveWordRecognitionVariants et SaveCharacterRecognitionVariants de l’objet [RecognizerParams](/fr/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/recognizerparams). FineReader Engine enregistrera ainsi les variantes de reconnaissance dans les résultats de reconnaissance.
2. Transmettez l’objet RecognizerParams en tant que sous-objet de l’objet [PageProcessingParams](/fr/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/pageprocessingparams) (ou de l’objet [DocumentProcessingParams](/fr/fine-reader/engine/api-reference/parameter-objects/preprocessing-analysis-recognition-and-synthesis-parameters/documentprocessingparams), qui le contient) à l’une des méthodes de reconnaissance d’ABBYY FineReader Engine.
3. La collection d’hypothèses est accessible après la reconnaissance via les propriétés [ICharParams::WordRecognitionVariants](/fr/fine-reader/engine/api-reference/text-related-objects/charparams#wordrecognitionvariants), [ICharParams::CharacterRecognitionVariants](/fr/fine-reader/engine/api-reference/text-related-objects/charparams#characterrecognitionvariants) et la méthode [IParagraph::GetWordRecognitionVariants](/fr/fine-reader/engine/api-reference/text-related-objects/paragraph/getwordrecognitionvariants-metho).

<Note>
  Ces méthodes renvoient zéro pour les caractères non imprimables (espaces, retours chariot, etc.) et les caractères qui n’ont pas été reconnus, mais ont été ajoutés au texte lors de l’édition. Zéro est également renvoyé si le texte a été reconnu par l’une des versions antérieures d’ABBYY FineReader Engine. Les collections d’hypothèses contiennent des variantes de reconnaissance classées de la meilleure à la moins bonne. Si la propriété SaveWordRecognitionVariants ou SaveCharacterRecognitionVariants de l’objet RecognizerParams est définie sur FALSE, la collection correspondante ne contiendra qu’un seul élément.
</Note>

<div id="windows-samples">
  ### Exemples Windows
</div>

<Accordion title="Code C++ (COM)">
  ```cpp theme={null}
  FREngine::IEnginePtr Engine;
  FREngine::IFRDocumentPtr frDocument;
  ...
  // Créer l'objet DocumentProcessingParams, configurer les paramètres,
  // et l'utiliser pendant la reconnaissance
  FREngine::IDocumentProcessingParamsPtr dpp = Engine->CreateDocumentProcessingParams();
  dpp->PageProcessingParams->RecognizerParams->SaveCharacterRecognitionVariants = VARIANT_TRUE;
  dpp->PageProcessingParams->RecognizerParams->SaveWordRecognitionVariants = VARIANT_TRUE;
  frDocument->Process( dpp );
  // Parcourir les blocs de mise en page
  FREngine::ILayoutPtr layout = frDocument->Pages->Item(0)->Layout;
  for (int i = 0; i < layout->Blocks->Count; i++) {
   if (layout->Blocks->Item(i)->Type == FREngine::BT_Text) {
    getVariants (layout->Blocks->Item(i));
   }
  }
  // Procédure de génération des hypothèses pour tous les mots et caractères d'un bloc de texte
  void getVariants(FREngine::IBlockPtr& block)
  {
   FREngine::ICharParamsPtr charParams = Engine->CreateCharParams();
   FREngine::IParagraphsPtr paragraphs = block->GetAsTextBlock()->Text->Paragraphs;
   for (int i = 0; i < paragraphs->Count; i++) {
    for (int j = 0; j < paragraphs->Item(i)->Length; j++) {
     paragraphs->Item(i)->GetCharParams(j, charParams);
     FREngine::ICharacterRecognitionVariantsPtr charVariants = charParams->CharacterRecognitionVariants;
     FREngine::IWordRecognitionVariantsPtr wordVariants = charParams->WordRecognitionVariants;
     if (wordVariants != 0) {
      for (int k = 0; k < wordVariants->Count; k++) {
       FREngine::IWordRecognitionVariantPtr wordVariant = wordVariants->Item(k);
      }
     }
     if (charVariants != 0) {
      for ( int k = 0; k < charVariants->Count; k++) {
       FREngine::ICharacterRecognitionVariantPtr charVariant = charVariants->Item(k);
      }
     }
    }
   }
  }
  ```
</Accordion>

<Accordion title="Code C#">
  ```csharp theme={null}
  FREngine.IEngine engine;
  FREngine.IFRDocument document;
  ...
  // Créer l'objet DocumentProcessingParams, configurer les paramètres,
  // et l'utiliser pendant la reconnaissance
  FREngine.IDocumentProcessingParams dpp = engine.CreateDocumentProcessingParams();
  dpp.PageProcessingParams.RecognizerParams.SaveCharacterRecognitionVariants = true;
  dpp.PageProcessingParams.RecognizerParams.SaveWordRecognitionVariants = true;
  document.Process( dpp );
  // Parcourir les blocs de mise en page
  FREngine.ILayout layout = document.Pages[0].Layout;
  for (int i = 0; i < layout.Blocks.Count; i++) {
   if (layout.Blocks[i].Type == FREngine.BlockTypeEnum.BT_Text) {
    getVariants (layout.Blocks[i]);
   }
  }
  // Procédure de génération des hypothèses pour tous les mots et caractères d'un bloc de texte
  void getVariants(FREngine.IBlock block)
  {
   FREngine.ICharParams charParams = engine.CreateCharParams();
   FREngine.IParagraphs paragraphs = block.GetAsTextBlock().Text.Paragraphs;
   for (int i = 0; i < paragraphs.Count; i++) {
    for (int j = 0; j < paragraphs[i].Length; j++) {
     paragraphs[i].GetCharParams(j, charParams);
     FREngine.ICharacterRecognitionVariants charVariants = charParams.CharacterRecognitionVariants;
     FREngine.IWordRecognitionVariants wordVariants = charParams.WordRecognitionVariants;
     if (wordVariants != null) {
      for (int k = 0; k < wordVariants.Count; k++) {
       FREngine.IWordRecognitionVariant wordVariant = wordVariants[k];
      }
     }
     if (charVariants != null) {
      for ( int k = 0; k < charVariants.Count; k++) {
       FREngine.ICharacterRecognitionVariant charVariant = charVariants[k];
      }
     }
    }
   }
  }
  ```
</Accordion>

<div id="what-is-the-difference-between-charconfidence-errorprobability-and-issuspicious">
  ## Quelle est la différence entre CharConfidence, ErrorProbability et IsSuspicious
</div>

Pour déterminer si un caractère a été reconnu de manière peu fiable et doit être vérifié, utilisez la propriété IsSuspicious des objets [PlainText](/fr/fine-reader/engine/api-reference/text-related-objects/plaintext/issuspicious-property) ou [CharParams](/fr/fine-reader/engine/api-reference/text-related-objects/charparams#issuspicious) pour le caractère donné. Elle est calculée à partir d’ErrorProbability.

Pour établir des distinctions plus fines, vous pouvez utiliser la propriété ErrorProbability des objets [PlainText](/fr/fine-reader/engine/api-reference/text-related-objects/plaintext/errorprobability-property) ou [CharParams](/fr/fine-reader/engine/api-reference/text-related-objects/charparams#errorprobability), qui renvoie la probabilité estimée (comprise entre 0 et 100) que le caractère ait été reconnu incorrectement. Elle tient compte du contexte dans lequel le caractère apparaît, par exemple du fait que le mot contenant ce caractère figure ou non dans le dictionnaire.

Vous pouvez également obtenir le niveau de confiance du caractère, à la fois pour un caractère reconnu (la propriété CharConfidence de l’objet [PlainText](/fr/fine-reader/engine/api-reference/text-related-objects/plaintext/charconfidence-property)) et pour toutes les variantes de reconnaissance (la propriété CharConfidence de l’objet [CharacterRecognitionVariant](/fr/fine-reader/engine/api-reference/text-related-objects/characterrecognitionvariant#charconfidence)). Le niveau de confiance fournit une estimation de la précision fondée uniquement sur l’image d’un seul caractère, sans tenir compte du contexte. Les estimations de confiance de différents caractères ne sont pas comparables, et la seule utilisation fiable du niveau de confiance consiste à comparer plusieurs variantes de reconnaissance de la même image (caractère).

Aucune de ces propriétés n’a de sens pour les symboles obtenus sans reconnaissance, par exemple ceux extraits directement du fichier PDF source.

<div id="see-also">
  ## Voir aussi
</div>

[CharacterRecognitionVariant](/fr/fine-reader/engine/api-reference/text-related-objects/characterrecognitionvariant)

[WordRecognitionVariant](/fr/fine-reader/engine/api-reference/text-related-objects/wordrecognitionvariant)