ReplacementText Classe

Definizione

Spazio dei nomi:

System.Speech.Recognition

Assembly:

System.Speech.dll

Contiene informazioni su una routine di normalizzazione vocale che è stata eseguita sui risultati del riconoscimento.

public ref class ReplacementText

[System.Serializable]
public class ReplacementText

[<System.Serializable>]
type ReplacementText = class

Public Class ReplacementText

Ereditarietà

Object

ReplacementText

Attributi

SerializableAttribute

Esempio

Nell'esempio seguente vengono visualizzate informazioni in un'interfaccia utente relative a un RecognizedPhrase oggetto restituito da un motore di riconoscimento.

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");  
      }  
    }  
  }    
}  

Commenti

La normalizzazione vocale è l'uso di costrutti o simboli speciali per esprimere il riconoscimento vocale.

Si supponga, ad esempio, che si tratta di un testo riconosciuto:

"il 4 luglio alle 12 31, ho acquistato un punto a sei chilogrammi di pesce per quattordici dollari e sei centesimi, a Pike Place Market a Seattle Washington 9 8 1 2 2"

Si tratta dello stesso testo dopo la normalizzazione:

"Il 4 luglio alle 12:31, ho acquistato 1,6 kg di pesce per $14,06, al Pike Place Market a Seattle WA 98122"

In questo esempio sono disponibili cinque sostituzioni, ognuna delle quali verrebbe descritta da un'istanza di ReplacementText .

Utilizzando l' ReplacementText oggetto, un'applicazione può determinare:

• La posizione e il numero di parole sostituite dalla normalizzazione. Per altre informazioni, vedere FirstWordIndex o CountOfWords.

• Testo sostituito e relativi attributi di visualizzazione. Per ulteriori informazioni, vedere Text e DisplayAttributes .

Le istanze di ReplacementText vengono in genere ottenute come membri dell' Collection<T> oggetto restituito dalla ReplacementWordUnits Proprietà in RecognizedPhrase (o classi che ereditano da RecognizedPhrase , ad esempio RecognitionResult ) quando il testo restituito è stato normalizzato.

Proprietà

CountOfWords	Ottiene il numero delle parole riconosciute sostituite con la procedura di normalizzazione vocale.
DisplayAttributes	Ottiene informazioni sugli spazi iniziali e finali del testo sostituito con la procedura di normalizzazione vocale.
FirstWordIndex	Ottiene la posizione della prima parola riconosciuta sostituita con la procedura di normalizzazione vocale.
Text	Ottiene il testo riconosciuto sostituito con la procedura di normalizzazione vocale.

Metodi

Equals(Object)	Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object)
GetHashCode()	Funge da funzione hash predefinita. (Ereditato da Object)
GetType()	Ottiene l'oggetto Type dell'istanza corrente. (Ereditato da Object)
MemberwiseClone()	Crea una copia superficiale dell'oggetto Object corrente. (Ereditato da Object)
ToString()	Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object)