ReplacementText Classe

Définition

Espace de noms:

System.Speech.Recognition

Assembly:

System.Speech.dll

Contient des informations sur une procédure de normalisation vocale qui a été exécutée sur les résultats de la reconnaissance.

public ref class ReplacementText

[System.Serializable]
public class ReplacementText

[<System.Serializable>]
type ReplacementText = class

Public Class ReplacementText

Héritage

Object

ReplacementText

Attributs

SerializableAttribute

Exemples

L’exemple ci-dessous affiche des informations dans une interface utilisateur sur un RecognizedPhrase objet retourné par un moteur de reconnaissance.

internal static void DisplayBasicPhraseInfo(  
        Label label,   
        RecognizedPhrase result,   
        SpeechRecognizer rec)   
{  
  if (result != null && label != null)   
  {  
    // Blank  
    if (rec != null)   
    {   
      // Clear  
      label.Text += String.Format(  
                             "  Recognizer currently at:   {0} mSec\n" +  
                             "  Audio Device currently at: {1} mSec\n",  
                             rec.RecognizerAudioPosition.TotalMilliseconds,  
                             rec.AudioPosition.TotalMilliseconds);  
    }  

    if (result != null)   
    { // Clear  
      RecognitionResult recResult = result as RecognitionResult;  
      if (recResult != null)   
      {  
        RecognizedAudio resultAudio = recResult.Audio;  
        if (resultAudio == null)   
        {  
          label.Text += String.Format("  Emulated input\n");  
        }   
        else   
        {  
          label.Text += String.Format(  
                               "  Candidate Phrase at:       {0} mSec\n" +  
                               "  Phrase Length:             {1} mSec\n" +  
                               "  Input State Time:          {2}\n" +  
                               "  Input Format:              {3}\n",  
                               resultAudio.AudioPosition.TotalMilliseconds,  
                               resultAudio.Duration.TotalMilliseconds,  
                               resultAudio.StartTime.ToShortTimeString(),  
                               resultAudio.Format.EncodingFormat.ToString());  
        }  
      }  

      label.Text += String.Format("  Confidence Level:          {0}\n", result.Confidence);  
      if (result.Grammar != null)   
      {  
        label.Text += String.Format(  
                            "  Recognizing Grammar:       {0}\n" +  
                            "  Recognizing Rule:          {1}\n",  
                            ((result.Grammar.Name != null) ? (result.Grammar.Name) : "None"),  
                            ((result.Grammar.RuleName != null) ? (result.Grammar.RuleName) : "None"));  
      }  

      if  (result.ReplacementWordUnits.Count !=  0)    
      {  
        label.Text += String.Format("  Replacement text:\n");  
        foreach (ReplacementText rep in result.ReplacementWordUnits)    
        {  
          string repText = rep.Text;  
          // Add trailing spaces  

          if ((rep.DisplayAttributes & DisplayAttributes.OneTrailingSpace) !=  0)    
          {  
            repText += " ";  
          }  
          if ((rep.DisplayAttributes & DisplayAttributes.TwoTrailingSpaces) !=  0)    
          {  
            repText += "  ";  
          }  
          if ((rep.DisplayAttributes & DisplayAttributes.ConsumeLeadingSpaces) != 0)    
          {  
            repText=repText.TrimStart();  
          }  
          if ((rep.DisplayAttributes & DisplayAttributes.ZeroTrailingSpaces) != 0)   
          {  
            repText = repText.TrimEnd();  
          }  
          label.Text += String.Format(  
                           "      At index {0} for {1} words. Text: \"{2}\"\n",  
                           rep.FirstWordIndex,  rep.CountOfWords, repText);  

        }  
        label.Text += String.Format("\n\n");  
      }  
    }  
  }    
}  

Remarques

La normalisation vocale consiste à utiliser des constructions ou des symboles spéciaux pour exprimer la parole en écriture.

Par exemple, supposons qu’il s’agit d’un texte reconnu :

« quatre juillet à 12 31, j’ai acheté un point de six kilogrammes de poisson pour quatorze dollars et six cents, sur le marché de la dénominations à Seattle Washington 9 8 1 2 2 »

Il s’agit du même texte après la normalisation :

« 4 juillet à 12:31, j’ai acheté 1,6 kg de poisson pour $14,06, sur le marché dénominations à Seattle WA 98122 »

Dans cet exemple, il existe cinq substitutions, chacune d’elles étant décrite par une instance de ReplacementText .

À l’aide de l' ReplacementText objet, une application peut déterminer les éléments suivants :

• Emplacement et nombre de mots remplacés par la normalisation. Pour plus d'informations, consultez FirstWordIndex ou CountOfWords.

• Texte remplacé et ses attributs d’affichage. Pour plus d’informations, consultez Text et DisplayAttributes .

Les instances de ReplacementText sont généralement obtenues en tant que membres de l' Collection<T> objet retourné par la ReplacementWordUnits propriété sur RecognizedPhrase (ou les classes qui héritent de RecognizedPhrase , telles que RecognitionResult ) lorsque le texte retourné a été normalisé.

Propriétés

CountOfWords	Obtient le nombre de mots identifiés remplacés par la procédure de normalisation vocale.
DisplayAttributes	Obtient des informations à propos des espaces de début et de fin du texte remplacé par la procédure de normalisation vocale.
FirstWordIndex	Obtient l'emplacement du premier mot identifié remplacé par la procédure de normalisation vocale.
Text	Obtient le texte reconnu remplacé par la procédure de normalisation vocale.

Méthodes

Equals(Object)	Détermine si l'objet spécifié est égal à l'objet actuel. (Hérité de Object)
GetHashCode()	Fait office de fonction de hachage par défaut. (Hérité de Object)
GetType()	Obtient le Type de l'instance actuelle. (Hérité de Object)
MemberwiseClone()	Crée une copie superficielle du Object actuel. (Hérité de Object)
ToString()	Retourne une chaîne qui représente l'objet actuel. (Hérité de Object)