Skip to main content

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.

Developers can combine several Engines in their recognition solutions. When multiple Engines generate different recognition variants for a character or word, the developer can select the best variant by voting between the variants. To enable voting, the ABBYY FineReader Engine has a special Voting API that provides access to different hypotheses of character or word recognition with corresponding weight values. In addition to voting, the developer can use the Voting API to check recognition results using his own databases and algorithms and to correct text. For example, the developer can build words from letters or check all generated hypotheses.
The Voting API is not available for handwritten/handprinted texts recognition.
The WordRecognitionVariants object represents a collection of hypotheses for a word, and the CharacterRecognitionVariants object represents a collection of hypotheses for a character. The elements of these collections are the WordRecognitionVariant and CharacterRecognitionVariant objects, respectively. The WordRecognitionVariant object represents a single hypothesis for a word and contains the text of the hypothesis, type of model, the average width of a stroke, and information on whether the hypothesis has been found in the dictionary. The GetCharParams method of this object provides access to the parameters of a single character. The CharacterRecognitionVariant object represents a single hypothesis for a character and contains character confidence, the probability that a character is written with a serif font, and information on whether the character is superscript or subscript.

​
How to retrieve recognition variants for a word or character

If you wish to find out all recognition hypotheses for a word or character, do the following:
  1. Set the SaveWordRecognitionVariants and SaveCharacterRecognitionVariants properties of the RecognizerParams object to TRUE. This will instruct FineReader Engine to save recognition variants in the recognition results.
  2. Pass the RecognizerParams object as a subobject of the PageProcessingParams object (or the DocumentProcessingParams object which contains it) to one of the ABBYY FineReader Engine recognition methods.
  3. The collection of hypotheses is accessible after recognition through the ICharParams::WordRecognitionVariants, ICharParams::CharacterRecognitionVariants properties and the IParagraph::GetWordRecognitionVariants method.
These methods return zero for non-printable characters (spaces, carriage returns, etc.) and characters that were not recognized but added to the text during editing. Zero is also returned if the text was recognized by one of the previous ABBYY FineReader Engine versions. The hypotheses collections contain recognition variants ranked from best to worst. If the SaveWordRecognitionVariants or SaveCharacterRecognitionVariants property of the RecognizerParams object is set to FALSE, the corresponding collection will contain only one element.

​
Windows Samples

FREngine::IEnginePtr Engine;
FREngine::IFRDocumentPtr frDocument;
...
// Create the DocumentProcessingParams object, set up the parameters,
// and use it during recognition
FREngine::IDocumentProcessingParamsPtr dpp = Engine->CreateDocumentProcessingParams();
dpp->PageProcessingParams->RecognizerParams->SaveCharacterRecognitionVariants = VARIANT_TRUE;
dpp->PageProcessingParams->RecognizerParams->SaveWordRecognitionVariants = VARIANT_TRUE;
frDocument->Process( dpp );
// Iterate layout blocks
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));
 }
}
// Procedure of hypotheses generation for all words and characters of a text block
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);
    }
   }
  }
 }
}

FREngine.IEngine engine;
FREngine.IFRDocument document;
...
// Create the DocumentProcessingParams object, set up the parameters,
// and use it during recognition
FREngine.IDocumentProcessingParams dpp = engine.CreateDocumentProcessingParams();
dpp.PageProcessingParams.RecognizerParams.SaveCharacterRecognitionVariants = true;
dpp.PageProcessingParams.RecognizerParams.SaveWordRecognitionVariants = true;
document.Process( dpp );
// Iterate layout blocks
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]);
 }
}
// Procedure of hypotheses generation for all words and characters of a text block
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];
    }
   }
  }
 }
}

​
What is the difference between CharConfidence, ErrorProbability, and IsSuspicious

To find out if a character was recognized unreliably and needs verification, use the IsSuspicious property of the PlainText or CharParams objects for the given character. It is calculated based on ErrorProbability. To implement more fine-grained distinctions, you can use the ErrorProbability property of the PlainText or CharParams objects, which returns the estimated probability (in range from 0 to 100) that the character was recognized incorrectly. It takes into account the context in which the character is found, for example, whether the word with this character is found in the dictionary. You can also get the character confidence, both for a recognized character (the CharConfidence property of the PlainText object) and for all recognition variants (the CharConfidence property of the CharacterRecognitionVariant object). The confidence provides an accuracy estimate based only on the image of one character, without considering the context. Confidence estimates for different characters are incomparable, and the only safe use of confidence is for comparing several recognition variants of the same image (character). None of these properties make sense for symbols obtained without recognition, for example, those taken directly from the source PDF file.

​
See also

CharacterRecognitionVariant WordRecognitionVariant