Vai al contenuto principale
Gli sviluppatori possono combinare diversi motori nelle proprie soluzioni di riconoscimento. Quando più motori generano varianti di riconoscimento diverse per un carattere o una parola, lo sviluppatore può selezionare la variante migliore tramite votazione tra le varianti. Per abilitare questa funzione, ABBYY FineReader Engine mette a disposizione una speciale Voting API che consente di accedere a diverse ipotesi di riconoscimento di caratteri o parole con i relativi valori di peso. Oltre alla votazione, lo sviluppatore può utilizzare la Voting API per verificare i risultati del riconoscimento usando i propri database e algoritmi e per correggere il testo. Ad esempio, lo sviluppatore può comporre parole a partire dalle lettere o controllare tutte le ipotesi generate.
La Voting API non è disponibile per il riconoscimento di testi manoscritti o in stampatello.
L’oggetto WordRecognitionVariants rappresenta una raccolta di ipotesi per una parola, mentre l’oggetto CharacterRecognitionVariants rappresenta una raccolta di ipotesi per un carattere. Gli elementi di queste raccolte sono, rispettivamente, gli oggetti WordRecognitionVariant e CharacterRecognitionVariant. L’oggetto WordRecognitionVariant rappresenta una singola ipotesi per una parola e contiene il testo dell’ipotesi, il tipo di modello, la larghezza media di un tratto e informazioni che indicano se l’ipotesi è stata trovata nel dizionario. Il metodo GetCharParams di questo oggetto consente di accedere ai parametri di un singolo carattere. L’oggetto CharacterRecognitionVariant rappresenta una singola ipotesi per un carattere e contiene il livello di confidenza del carattere, la probabilità che un carattere sia scritto con un font con grazie e informazioni che indicano se il carattere è in apice o in pedice.

​
Come recuperare le varianti di riconoscimento per una parola o un carattere

Se desideri visualizzare tutte le ipotesi di riconoscimento per una parola o un carattere, procedi come segue:
  1. Imposta su TRUE le proprietà SaveWordRecognitionVariants e SaveCharacterRecognitionVariants dell’oggetto RecognizerParams. In questo modo, FineReader Engine salverà le varianti di riconoscimento nei risultati del riconoscimento.
  2. Passa l’oggetto RecognizerParams come sotto-oggetto dell’oggetto PageProcessingParams (o dell’oggetto DocumentProcessingParams, che lo contiene) a uno dei metodi di riconoscimento di ABBYY FineReader Engine.
  3. È possibile accedere alla raccolta delle ipotesi dopo il riconoscimento tramite le proprietà ICharParams::WordRecognitionVariants, ICharParams::CharacterRecognitionVariants e il metodo IParagraph::GetWordRecognitionVariants.
Questi metodi restituiscono zero per i caratteri non stampabili (spazi, ritorni a capo e così via) e per i caratteri non riconosciuti ma aggiunti al testo durante la modifica. Zero viene restituito anche se il testo è stato riconosciuto da una delle versioni precedenti di ABBYY FineReader Engine. Le raccolte di ipotesi contengono varianti di riconoscimento classificate dalla migliore alla peggiore. Se la proprietà SaveWordRecognitionVariants o SaveCharacterRecognitionVariants dell’oggetto RecognizerParams è impostata su FALSE, la raccolta corrispondente conterrà un solo elemento.

​
Esempi Windows

FREngine::IEnginePtr Engine;
FREngine::IFRDocumentPtr frDocument;
...
// Crea l'oggetto DocumentProcessingParams, imposta i parametri
// e utilizzalo durante il riconoscimento
FREngine::IDocumentProcessingParamsPtr dpp = Engine->CreateDocumentProcessingParams();
dpp->PageProcessingParams->RecognizerParams->SaveCharacterRecognitionVariants = VARIANT_TRUE;
dpp->PageProcessingParams->RecognizerParams->SaveWordRecognitionVariants = VARIANT_TRUE;
frDocument->Process( dpp );
// Itera sui blocchi di layout
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));
 }
}
// Procedura di generazione delle ipotesi per tutte le parole e i caratteri di un blocco di testo
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;
...
// Crea l'oggetto DocumentProcessingParams, imposta i parametri
// e utilizzalo durante il riconoscimento
FREngine.IDocumentProcessingParams dpp = engine.CreateDocumentProcessingParams();
dpp.PageProcessingParams.RecognizerParams.SaveCharacterRecognitionVariants = true;
dpp.PageProcessingParams.RecognizerParams.SaveWordRecognitionVariants = true;
document.Process( dpp );
// Itera sui blocchi di layout
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]);
 }
}
// Procedura di generazione delle ipotesi per tutte le parole e i caratteri di un blocco di testo
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];
    }
   }
  }
 }
}

​
Qual è la differenza tra CharConfidence, ErrorProbability e IsSuspicious

Per determinare se un carattere è stato riconosciuto in modo inaffidabile e richiede una verifica, usa la proprietà IsSuspicious degli oggetti PlainText o CharParams per il carattere in questione. Questa proprietà viene calcolata in base a ErrorProbability. Per introdurre distinzioni più precise, puoi usare la proprietà ErrorProbability degli oggetti PlainText o CharParams, che restituisce la probabilità stimata (in un intervallo da 0 a 100) che il carattere sia stato riconosciuto in modo errato. Tiene conto del contesto in cui compare il carattere, ad esempio del fatto che la parola che lo contiene sia presente nel dizionario. Puoi anche ottenere il livello di confidenza del carattere, sia per un carattere riconosciuto (la proprietà CharConfidence dell’oggetto PlainText) sia per tutte le varianti di riconoscimento (la proprietà CharConfidence dell’oggetto CharacterRecognitionVariant). Il livello di confidenza fornisce una stima dell’accuratezza basata solo sull’immagine di un singolo carattere, senza tenere conto del contesto. Le stime di confidenza per caratteri diversi non sono confrontabili e l’unico uso affidabile della confidenza è il confronto tra più varianti di riconoscimento della stessa immagine (carattere). Nessuna di queste proprietà è significativa per i simboli ottenuti senza riconoscimento, ad esempio quelli prelevati direttamente dal file PDF di origine.

​
Vedi anche

CharacterRecognitionVariant WordRecognitionVariant