/// <summary> /// Default Constructor /// </summary> public CreateGesture() { InitializeComponent(); //this.Gesture = new tempuri.org.GestureDefinition.xsd.Gesture(); this.Gesture = new IavaGesture(); // If we are in design mode, do nothing... if (DesignerProperties.GetIsInDesignMode(this)) { return; } // Subscribe to the Camera events we are interested in... try { IavaCamera.ImageFrameReady += OnCameraImageFrameReady; IavaCamera.SkeletonFrameReady += OnCameraSkeletonFrameReady; } catch (Exception e) { } // Set up the Audio Recognizer... AudioRecognizer = new AudioRecognizer(); AudioRecognizer.SyncCommand = "IAVA"; AudioRecognizer.Subscribe("Capture", CaptureCallback); AudioRecognizer.Subscribe("Snapshot", CaptureCallback); AudioRecognizer.Start(); }
public MainWindow() { InitializeComponent(); AudioRecognizer = new Iava.Audio.AudioRecognizer(); AudioRecognizer.Subscribe("Create Gesture", CreateAudioCallback); AudioRecognizer.Subscribe("Test Gesture", TestAudioCallback); AudioRecognizer.Subscribe("Exit", ExitAudioCallback); AudioRecognizer.Start(); CreateGesture.Visibility = System.Windows.Visibility.Hidden; TestGesture.Visibility = System.Windows.Visibility.Hidden; }
public void RecognizerOnStatusChangedTest() { // Since we're treating this as the generic Recognizer this is ok Recognizer recognizer = new AudioRecognizer(); bool eventFired = false; // Register for the Recognizer StatusChanged Event recognizer.StatusChanged += (param1, param2) => eventFired = true; try { // Simulate the StatusChanged Event PrivateObject privateObject = new PrivateObject(recognizer); privateObject.Invoke("OnStatusChanged", null, EventArgs.Empty); Thread.Sleep(50); // Make sure the Recognizer StatusChanged Event was fired Assert.IsTrue(eventFired); } catch (Exception ex) { Assert.Fail(ex.Message); } }
public void RecognizerSyncTimeoutValueTest() { // Since we're treating this as the generic Recognizer this is ok Recognizer recognizer = new AudioRecognizer(); int timeout = 123456; try { // Set the Timeout Value recognizer.SyncTimeoutValue = timeout; // Make sure the Timeout Value was updated Assert.AreEqual(timeout, recognizer.SyncTimeoutValue); } catch (Exception ex) { Assert.Fail(ex.Message); } }
public void RecognizerStatusTest() { // Since we're treating this as the generic Recognizer this is ok Recognizer recognizer = new AudioRecognizer(); bool eventFired = false; // Register for the Recognizer StatusChanged Event recognizer.StatusChanged += (param1, param2) => eventFired = true; try { // Simulate the StatusChanged Event with the Error status PrivateObject privateObject = new PrivateObject(recognizer); privateObject.SetProperty("Status", RecognizerStatus.Error); Thread.Sleep(50); // Make sure the Recognizer Status was updated Assert.AreEqual(RecognizerStatus.Error, recognizer.Status); // Make sure the Recognizer StatusChanged Event was fired Assert.IsTrue(eventFired); // Reset the event eventFired = false; // Simulate the StatusChanged Event with the NotReady status privateObject.SetProperty("Status", RecognizerStatus.NotReady); Thread.Sleep(50); // Make sure the Recognizer Status was updated Assert.AreEqual(RecognizerStatus.NotReady, recognizer.Status); // Make sure the Recognizer StatusChanged Event was fired Assert.IsTrue(eventFired); // Reset the event eventFired = false; // Simulate the StatusChanged Event with the Ready status privateObject.SetProperty("Status", RecognizerStatus.Ready); Thread.Sleep(50); // Make sure the Recognizer Status was updated Assert.AreEqual(RecognizerStatus.Ready, recognizer.Status); // Make sure the Recognizer StatusChanged Event was fired Assert.IsTrue(eventFired); // Reset the event eventFired = false; // Simulate the StatusChanged Event with the Running status privateObject.SetProperty("Status", RecognizerStatus.Running); Thread.Sleep(50); // Make sure the Recognizer Status was updated Assert.AreEqual(RecognizerStatus.Running, recognizer.Status); // Make sure the Recognizer StatusChanged Event was fired Assert.IsTrue(eventFired); } catch (Exception ex) { Assert.Fail(ex.Message); } }
/// <summary> /// Default Constructor /// </summary> public MainWindow() { InitializeComponent(); const string gesturesPath = @"..\..\..\Gestures\"; m_pGestureRecognizer = new Gesture.GestureRecognizer(gesturesPath); m_pAudioRecognizer = new AudioRecognizer(); m_pAudioRecognizer.AudioConfidenceThreshold = 0.8f; // Initialize the CityLocations class by calling a method on it CityLocations.GetCityLocation("test"); // Events m_pAudioRecognizer.StatusChanged += OnAudioRecognizerStatusChanged; m_pGestureRecognizer.StatusChanged += OnGestureRecognizerStatusChanged; m_pAudioRecognizer.Synced += OnAudioRecognizerSynced; m_pGestureRecognizer.Synced += OnGestureRecognizerSynced; m_pAudioRecognizer.Unsynced += OnAudioRecognizerUnsynced; m_pGestureRecognizer.Unsynced += OnGestureRecognizerUnsynced; // Gesture Callbacks string[] mappedGestureNames = new[] { "Zoom In", "Zoom Out", "Swipe Left", "Swipe Right", "Swipe Up", "Swipe Down" }; m_pGestureRecognizer.Subscribe(mappedGestureNames[0], GestureZoomInCallback); m_pGestureRecognizer.Subscribe(mappedGestureNames[1], GestureZoomOutCallback); m_pGestureRecognizer.Subscribe(mappedGestureNames[2], GestureSwipeLeftCallback); m_pGestureRecognizer.Subscribe(mappedGestureNames[3], GestureSwipeRightCallback); m_pGestureRecognizer.Subscribe(mappedGestureNames[4], GestureSwipeUpCallback); m_pGestureRecognizer.Subscribe(mappedGestureNames[5], GestureSwipeDownCallback); // Add unmapped gestures so that they will be recognized foreach (IavaGesture gesture in GestureFolderReader.Read(gesturesPath)) { if (!Equals("Sync", gesture.Name) && !mappedGestureNames.Contains<string>(gesture.Name)) { m_pGestureRecognizer.Subscribe(gesture.Name, GestureUnmappedCallback); } } // Audio Callbacks m_pAudioRecognizer.Subscribe("Zoom In", ZoomInCallback); m_pAudioRecognizer.Subscribe("Zoom Out", ZoomOutCallback); m_pAudioRecognizer.Subscribe("Move North", MoveNorthCallback); m_pAudioRecognizer.Subscribe("Move South", MoveSouthCallback); m_pAudioRecognizer.Subscribe("Move East", MoveEastCallback); m_pAudioRecognizer.Subscribe("Move West", MoveWestCallback); m_pAudioRecognizer.Subscribe("Exit Application", BlowUp); m_pAudioRecognizer.Subscribe("Locate *", LocateCityCallback); m_pAudioRecognizer.Subscribe("Get Recognizer Statuses", GetRecognizerStatusesCallback); IavaCamera.ImageFrameReady += OnCameraImageFrameReady; IavaCamera.SkeletonFrameReady += OnCameraSkeletonFrameReady; m_pAudioSyncTimer = new System.Timers.Timer(1000); m_pAudioSyncTimer.Elapsed += OnAudioSyncTimerElapsed; m_pGestureSyncTimer = new System.Timers.Timer(1000); m_pGestureSyncTimer.Elapsed += OnGestureSyncTimerElapsed; m_pConsoleTxtBox = new TextBoxStreamWriter(this.txtConsole); Console.SetOut(m_pConsoleTxtBox); // UI theme stuff... lblAudioStatus.Background = lblGestureStatus.Background = unsyncedBrush; lblAudioSyncTime.Background = lblGestureSyncTime.Background = backgroundBrush; lblAudioTTL.Background = lblGestureTTL.Background = backgroundBrush; }
public void AudioStartTest() { recognizer = new AudioRecognizer(); Assert.AreEqual<RecognizerStatus>(RecognizerStatus.NotReady, recognizer.Status); recognizer.Started += RecognizerStatusCallback; try { recognizer.Start(); Assert.AreEqual<RecognizerStatus>(RecognizerStatus.Running, recognizer.Status); // Ensure the OnStarted callback was invoked Thread.Sleep(1000); Assert.IsTrue(recognizerCallbackInvoked, "OnStarted callback was not invoked."); recognizer.Start(); Assert.AreEqual<RecognizerStatus>(RecognizerStatus.Running, recognizer.Status); } finally { if (recognizer != null) { recognizer.Started -= RecognizerStatusCallback; } } }
public void MyTestCleanup() { recognizerCallbackInvoked = false; if (recognizer != null) { recognizer.Stop(); } recognizer = null; resetEvent.Reset(); }
public void AudioWildcardTest() { // Create a mock speech engine and set it up var mockEngine = SetupMockSpeechRecognitionEngine(); recognizer = new AudioRecognizer(mockEngine.Object); const string commandString = "Test Callback *"; string eventArgsCommand = null; List<string> commands = null; recognizer.Subscribe(commandString, (eventArgs) => { eventArgsCommand = eventArgs.Command; commands = eventArgs.CommandWildcards; resetEvent.Set(); }); recognizer.Start(); // Sync the recognizer mockEngine.Raise(m => m.SpeechRecognized += null, new IavaSpeechRecognizedEventArgs(recognizer.SyncCommand, recognizer.AudioConfidenceThreshold + 0.01f)); Thread.Sleep(50); // Raise the recognized command const string wildcardPhrase = "one two three"; mockEngine.Raise(m => m.SpeechRecognized += null, new IavaSpeechRecognizedEventArgs(commandString.Replace('*', ' ') + wildcardPhrase, recognizer.AudioConfidenceThreshold + 0.01f)); Assert.IsTrue(resetEvent.WaitOne(TimeoutValue)); Assert.AreEqual(commandString, eventArgsCommand, "Command string returned did not match expected value."); Assert.IsNotNull(commands); Assert.AreEqual(3, commands.Count); Assert.AreEqual("one", commands[0]); Assert.AreEqual("two", commands[1]); Assert.AreEqual("three", commands[2]); }
public void AudioUnsubscribeTest() { const string commandString = "Test Callback"; // Create a mock speech engine and set it up var mockEngine = SetupMockSpeechRecognitionEngine(); recognizer = new AudioRecognizer(mockEngine.Object); // Test the audio confidence level try { recognizer.AudioConfidenceThreshold = -0.5f; } catch (Exception e) { Assert.IsInstanceOfType(e, typeof(ArgumentOutOfRangeException)); } try { recognizer.AudioConfidenceThreshold = 1.01f; } catch (Exception e) { Assert.IsInstanceOfType(e, typeof(ArgumentOutOfRangeException)); } recognizer.AudioConfidenceThreshold = 0.6f; // Raise the speech recognized event, unsubscribe the event, and try the command again string eventArgsCommand = null; recognizer.Subscribe(commandString, (eventArgs) => { eventArgsCommand = eventArgs.Command; resetEvent.Set(); }); recognizer.Start(); mockEngine.Raise(m => m.SpeechRecognized += null, new IavaSpeechRecognizedEventArgs(recognizer.SyncCommand, recognizer.AudioConfidenceThreshold + 0.01f)); Thread.Sleep(50); mockEngine.Raise(m => m.SpeechRecognized += null, new IavaSpeechRecognizedEventArgs(commandString, recognizer.AudioConfidenceThreshold + 0.01f)); Assert.IsTrue(resetEvent.WaitOne(TimeoutValue)); Assert.AreEqual(commandString, eventArgsCommand, "Command string returned did not match expected value."); resetEvent.Reset(); // Unsubscribe the callback and ensure it is not called when the audio command was recognized recognizer.Unsubscribe(commandString); mockEngine.Raise(m => m.SpeechRecognized += null, new IavaSpeechRecognizedEventArgs(commandString, recognizer.AudioConfidenceThreshold + 0.01f)); Assert.IsFalse(resetEvent.WaitOne(TimeoutValue)); // For code coverage try { recognizer.Unsubscribe(null); } catch (Exception e) { Assert.IsInstanceOfType(e, typeof(ArgumentException)); } try { recognizer.Unsubscribe("Non Existant Key"); } catch (Exception e) { Assert.IsInstanceOfType(e, typeof(ArgumentException)); } }
public void AudioSyncUnsyncTest() { const string commandString = "Test Callback"; // Create a mock speech engine and set it up var mockEngine = SetupMockSpeechRecognitionEngine(); recognizer = new AudioRecognizer(mockEngine.Object); recognizer.SyncTimeoutValue = 500; recognizer.Synced += (sender, args) => { resetEvent.Set(); }; recognizer.Unsynced += (sender, args) => { resetEvent.Set(); }; // Sync the recognizer, call a command, wait until un-sync and re-call the same command. // Ensure the callback is not called twice. string eventArgsCommand = null; recognizer.Subscribe(commandString, (eventArgs) => { eventArgsCommand = eventArgs.Command; resetEvent.Set(); }); recognizer.Start(); mockEngine.Raise(m => m.SpeechRecognized += null, new IavaSpeechRecognizedEventArgs(recognizer.SyncCommand, recognizer.AudioConfidenceThreshold + 0.01f)); Assert.IsTrue(resetEvent.WaitOne(TimeoutValue)); resetEvent.Reset(); mockEngine.Raise(m => m.SpeechRecognized += null, new IavaSpeechRecognizedEventArgs(commandString, recognizer.AudioConfidenceThreshold + 0.01f)); Assert.IsTrue(resetEvent.WaitOne(TimeoutValue)); Assert.AreEqual(commandString, eventArgsCommand, "Command string returned did not match expected value."); resetEvent.Reset(); Assert.IsTrue(resetEvent.WaitOne(recognizer.SyncTimeoutValue + 100)); resetEvent.Reset(); mockEngine.Raise(m => m.SpeechRecognized += null, new IavaSpeechRecognizedEventArgs(commandString, recognizer.AudioConfidenceThreshold + 0.01f)); Assert.IsFalse(resetEvent.WaitOne(TimeoutValue)); }
public void AudioSyncCommandTest() { // Create a mock speech engine and set it up var mockEngine = SetupMockSpeechRecognitionEngine(); recognizer = new AudioRecognizer(mockEngine.Object); // Test changing the sync command try { recognizer.SyncCommand = null; } catch (Exception exception) { Assert.IsInstanceOfType(exception, typeof(ArgumentException)); } try { recognizer.SyncCommand = string.Empty; } catch (Exception exception) { Assert.IsInstanceOfType(exception, typeof(ArgumentException)); } try { recognizer.SyncCommand = " "; } catch (Exception exception) { Assert.IsInstanceOfType(exception, typeof(ArgumentException)); } recognizer.SyncCommand = "Test Sync Command"; const string commandString = "Test Callback"; string eventArgsCommand = null; recognizer.Subscribe(commandString, (eventArgs) => { eventArgsCommand = eventArgs.Command; resetEvent.Set(); }); recognizer.Start(); // Sync the callback first then raise spoken event mockEngine.Raise(m => m.SpeechRecognized += null, new IavaSpeechRecognizedEventArgs(recognizer.SyncCommand, recognizer.AudioConfidenceThreshold + 0.01f)); Thread.Sleep(50); mockEngine.Raise(m => m.SpeechRecognized += null, new IavaSpeechRecognizedEventArgs(commandString, recognizer.AudioConfidenceThreshold + 0.01f)); Assert.IsTrue(resetEvent.WaitOne(TimeoutValue)); Assert.AreEqual(commandString, eventArgsCommand, "Command string returned did not match expected value."); resetEvent.Reset(); // Change the sync command, re-sync and recognize the command again recognizer.SyncCommand = "Open the pod bay doors HAL..."; mockEngine.Raise(m => m.SpeechRecognized += null, new IavaSpeechRecognizedEventArgs(recognizer.SyncCommand, recognizer.AudioConfidenceThreshold + 0.01f)); Thread.Sleep(50); mockEngine.Raise(m => m.SpeechRecognized += null, new IavaSpeechRecognizedEventArgs(commandString, recognizer.AudioConfidenceThreshold + 0.01f)); Assert.IsTrue(resetEvent.WaitOne(TimeoutValue)); }
public void AudioSubscribeTest() { const string commandString = "Test Callback"; // Create a mock speech engine and set it up var mockEngine = SetupMockSpeechRecognitionEngine(); recognizer = new AudioRecognizer(mockEngine.Object); string eventArgsCommand = null; recognizer.Subscribe(commandString, (eventArgs) => { eventArgsCommand = eventArgs.Command; resetEvent.Set(); }); // Test for exception throwing on invalid parameters entered try { recognizer.Subscribe(string.Empty, (eventArgs) => { }); } catch (Exception ex) { Assert.IsInstanceOfType(ex, typeof(ArgumentException)); } try { recognizer.Subscribe(commandString, null); } catch (Exception ex) { Assert.IsInstanceOfType(ex, typeof(ArgumentException)); } recognizer.Start(); const string commandString2 = "Command String 2"; string eventArgsCommand2 = null; recognizer.Subscribe(commandString2, (eventArgs) => { eventArgsCommand2 = eventArgs.Command; resetEvent.Set(); }); // Sync the callback first then raise spoken event mockEngine.Raise(m => m.SpeechRecognized += null, new IavaSpeechRecognizedEventArgs("Blah Blah blah", recognizer.AudioConfidenceThreshold + 0.01f)); mockEngine.Raise(m => m.SpeechRecognized += null, new IavaSpeechRecognizedEventArgs(recognizer.SyncCommand, recognizer.AudioConfidenceThreshold + 0.01f)); Thread.Sleep(200); mockEngine.Raise(m => m.SpeechRecognized += null, new IavaSpeechRecognizedEventArgs(commandString, recognizer.AudioConfidenceThreshold + 0.01f)); Thread.Sleep(200); mockEngine.Raise(m => m.SpeechRecognized += null, new IavaSpeechRecognizedEventArgs("Blah Blah blah", recognizer.AudioConfidenceThreshold + 0.01f)); Assert.IsTrue(resetEvent.WaitOne(TimeoutValue)); Assert.AreEqual(commandString, eventArgsCommand, "Command string returned did not match expected value."); resetEvent.Reset(); // Callback with the same command but with confidence below the threshold level to ensure the audio callback method is not called mockEngine.Raise(m => m.SpeechRecognized += null, new IavaSpeechRecognizedEventArgs(commandString, recognizer.AudioConfidenceThreshold - 0.01f)); Thread.Sleep(200); Assert.IsFalse(resetEvent.WaitOne(TimeoutValue)); // Call second command and wait for callback to be invoked mockEngine.Raise(m => m.SpeechRecognized += null, new IavaSpeechRecognizedEventArgs(commandString2, 0.95f)); Assert.IsTrue(resetEvent.WaitOne(TimeoutValue)); Assert.AreEqual(commandString2, eventArgsCommand2, "Command string returned did not match expected value."); resetEvent.Reset(); // For code coverage try { recognizer.Subscribe(commandString2, (eventArgs) => { }); } catch (Exception e) { Assert.IsInstanceOfType(e, typeof(ArgumentException)); } }
public void AudioStopTest() { recognizer = new AudioRecognizer(); Assert.AreEqual<RecognizerStatus>(RecognizerStatus.NotReady, recognizer.Status); recognizer.Stopped += RecognizerStatusCallback; try { recognizer.Start(); Assert.AreEqual<RecognizerStatus>(RecognizerStatus.Running, recognizer.Status); recognizer.Stop(); Thread.Sleep(1000); Assert.AreEqual<RecognizerStatus>(RecognizerStatus.Ready, recognizer.Status); Assert.IsTrue(recognizerCallbackInvoked, "OnStopped callback was not invoked."); // Start and stop immediately after one another and ensure it can be started again recognizer.Start(); recognizer.Stop(); Assert.AreEqual<RecognizerStatus>(RecognizerStatus.Ready, recognizer.Status); recognizer.Start(); Assert.AreEqual<RecognizerStatus>(RecognizerStatus.Running, recognizer.Status); } finally { if (recognizer != null) { recognizer.Stopped -= RecognizerStatusCallback; } } }