Export (0) Print
Expand All
1 out of 1 rated this helpful - Rate this topic

SemanticValue Class

Represents the semantic organization of a recognized phrase.

Namespace: System.Speech.Recognition
Assembly: System.Speech (in system.speech.dll)

[SerializableAttribute] 
public sealed class SemanticValue : IDictionary<string,SemanticValue>, ICollection<KeyValuePair<string,SemanticValue>>, 
	IEnumerable<KeyValuePair<string,SemanticValue>>, IEnumerable
/** @attribute SerializableAttribute() */ 
public final class SemanticValue implements IDictionary<String,SemanticValue>, 
	ICollection<KeyValuePair<String,SemanticValue>>, IEnumerable<KeyValuePair<String,SemanticValue>>, IEnumerable
SerializableAttribute 
public final class SemanticValue implements IDictionary<String,SemanticValue>, 
	ICollection<KeyValuePair<String,SemanticValue>>, IEnumerable<KeyValuePair<String,SemanticValue>>, IEnumerable
Not applicable.

The SemanticValue is primary object implementing the semantic technology. Semantic interpretation allows grammars to define, and recognition engines to correctly interpret, audio input but organized into more easily processable information, not just as words and sequences of words.

For example, the recognition engine output "Change background to red" would have to be parsed and interpreted by an application before it could be acted upon.

However, a Grammar object can specify an semantic interpretation to make processing clearer.

In the case of the phrase "Change background to red", the Grammar could specify that the phrase has two semantic substructures, one for selecting background or foreground (represented by the text "background"), the other for selecting color (represented by the text "red").

This semantic interpretation by recognition engine is expressed in a tree of SemanticValue objects.

SemanticValue implements of the System.Collection.Generic.IDictionary, System.Collections.Generic.ICollection and System.Collections.Generic.IEnumerable interfaces.

Under the semantics of a recognition operation are represented in a tree of SemanticValue objects.

Each SemanticValue instance has

  • A System.Objecttype, accessed using the Value property, used to key the instance of the SemanticValue.

  • A measure of accuracy returned by the Confidence property

  • A collection name value pairs (System.Collections.Generic.KeyValuePair) of child objects, which are also SemanticValue instances. Child nodes are accessible through the SemanticValue implementation of System.Collection.Generic.IDictionary using with a string lookup key and a SemanticValue instance, for example:

    foreach (KeyValuePair<String, SemanticValue> child in semantics) {
       Utils.CreateSemanticsTreeNodes(semanticsNode.Nodes, child.Value, child.Key);
    }
    

All based recognition engine output provide valid instances of SemanticValue for all recognized output, even phrases with no explicit semantic structure.

The SemanticValue instance for a phrase is obtained using the Semantics property on the RecognizedPhrase object (or objects which inherirt from it, such as RecognitionResult).

SemanticValue object obtained for recognized phrases without semantic structure are characterized by:

  • Having no children (Count is 0)

  • The Value property is a null reference (Nothing in Visual Basic).

  • An artificial confidence level of 1.0 (returned by Confidence)

Typically, applications create instance of SemanticValue indirectly, adding them to Grammar objects by using SemanticResultValue, and SemanticResultKey instances in conjunction with, Choices and GrammarBuilder objects.

Director construction of an SemanticValue is useful during the creation of strongly typed grammars.

The example below shows a handler for a SpeechRecognized event designed to handle commands to change foreground and background color.

Cases where phrases are recognized, but have no semantic structure, are identified by the handler by having Count of zero and a Value of a null reference (Nothing in Visual Basic). This recognition output is then processed directly from the parsing the raw text.

In other cases, the handler obtains specific information about whether the command is to set the foreground or background color, and the RGB of official name of a color setting based on keys, or indicates that no valid key was found.


newGrammar.SpeechRecognized +=
    delegate(object sender, SpeechRecognizedEventArgs eventArgs) {
        // Retrieve the value of the semantic property.
        bool changeBackGround = true;
        string errorString = "";
        SemanticValue semantics = eventArgs.Result.Semantics;

        Color newColor = Color.Empty;
        

        try {
            if (semantics.Count == 0 && semantics.Value==null){
                
                //This signature of recognition by grammar with no semantic
                ////We have to parse the string. hope last word is color, search for background or forground in input
                if (eventArgs.Result.Text.Contains("foreground")) {
                    changeBackGround = false;
                }
                string cName = eventArgs.Result.Words[eventArgs.Result.Words.Count - 1].Text;
                newColor = Color.FromName(cName);
            
            }else if (semantics.ContainsKey("colorStringList") ^ semantics.ContainsKey("colorRGBValueList")) {
                //Check background vs foreground

                if (semantics.ContainsKey("applyChgToBackground")) {
                    changeBackGround = semantics["applyChgToBackground"].Value is bool;
                }

                //Get color value
                if (semantics.ContainsKey("colorStringList")) {
                    newColor = Color.FromName((string)semantics["colorStringList"].Value);
                }
                if (semantics.ContainsKey("colorRGBValueList")) {
                    newColor = System.Drawing.Color.FromArgb((int)semantics["colorRGBValueList"].Value);
                }
            } else {
                //we have a semantics that does not contain the keys we support, throw an exception.
                throw(new Exception("Unsupported semantics keys found."));
            }

        } catch (Exception exp) {
            MessageBox.Show(String.Format("Unable to process color semantics.:\n{0}\n", exp.Message));
            return;
        }
        //Change colors, either foreground or background.
        if (changeBackGround) {
            BackColor = newColor;
            float Bright = BackColor.GetBrightness();
            float Hue = BackColor.GetHue();
            float Sat = BackColor.GetSaturation();
            //Make sure the text is readable regardless of background.
            if (BackColor.GetBrightness() <= .50) {
                ForeColor = Color.White;
            } else {
                ForeColor = Color.Black;
            }
        } else {
            ForeColor = newColor;
            float Bright = ForeColor.GetBrightness();
            float Hue = ForeColor.GetHue();
            float Sat = ForeColor.GetSaturation();
            //Make sure the text is readable regardless of Foreground.
            if (ForeColor.GetBrightness() <= .50) {
                BackColor = Color.White;
            } else {
                BackColor = Color.Black;
            }
        }
        Return;
    };
System.Object
  System.Speech.Recognition.SemanticValue
Any public static (Shared in Visual Basic) members of this type are thread safe. Any instance members are not guaranteed to be thread safe.

Windows 98, Windows Server 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile for Pocket PC, Windows Mobile for Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

The Microsoft .NET Framework 3.0 is supported on Windows Vista, Microsoft Windows XP SP2, and Windows Server 2003 SP1.

.NET Framework

Supported in: 3.0
Did you find this helpful?
(1500 characters remaining)
Thank you for your feedback

Community Additions

ADD
Show:
© 2014 Microsoft. All rights reserved.