Choreoh.MainWindow.recoEngine_SpeechRecognized C# (CSharp) Метод

recoEngine_SpeechRecognized() приватный Метод

private recoEngine_SpeechRecognized ( object sender, System e ) : void
sender object
e System
Результат void
        void recoEngine_SpeechRecognized(object sender, System.Speech.Recognition.SpeechRecognizedEventArgs e)
        {
            var alternates = e.Result.Alternates;
            String alternates_string = "";
            String[] alternates_string_array = new String[alternates.Count];
            string[] isolate_result_array;

            foreach (RecognizedPhrase i in alternates)
            {
                int j = 0;
                alternates_string = alternates_string + " " + i.Text.ToString();
                alternates_string_array[j] = alternates_string + " " + i.Text.ToString();
                j++;
            }

            string[] recognizableCommands = { "START", "SAVE", "REDO", "CANCEL", "PLAY" };

            string recognizedResult = e.Result.Text.ToString().Trim();
            string recognizedResultUpper = recognizedResult.ToUpperInvariant();
            bool found = false;

            //isolates key word from multi word recognition.
            if (recognizedResultUpper.Contains(' '))
            {
                isolate_result_array = recognizedResult.Split(' ');

                for (int i = 0; i < isolate_result_array.Length; i++)
                {
                    for (int j = 0; j < recognizableCommands.Length; j++)
                        if (isolate_result_array[i].Equals(recognizableCommands[j]))
                        {
                            recognizedResultUpper = recognizableCommands[j];
                            found = true;
                            break;
                        }
                    if (found)
                    {
                        break;
                    }
                }
            }

            //int startOfSegment = 0;
            if (annotating)
            {
                if (e.Result.Confidence < 0.5)
                {
                    this.RejectSpeech(e.Result);

                    return;
                }
                else
                {
                    //alternates_label.Content = alternates_string;
                    this.RecognizeSpeech(e.Result);
                    return;
                }
            }
            if (pre_recording)
            {
                Debug.WriteLine("Pre-recording Speech detected: " + e.Result.Text.ToString());
                int startOfSegment = 0;
                switch (recognizedResultUpper)
                {
                    case "START":
                    case "STARTS":
                    case "STARTED":
                    case "TARTS":
                    case "DART":
                    case "TART":
                    case "CART":
                    case "HEART":
                    case "PART":
                    case "RESTART":
                    case "UPSTART":
                        //start_label.Visibility = Visibility.Visible;
                        blackBack.Visibility = Visibility.Collapsed;
                        beforeRecordCanvas.Visibility = Visibility.Collapsed;
                        pre_recording = false;

                        showRecordingCanvas();
                        switchModeToRecording();

                        double duration = endSecondsIntoWaveform - startSecondsIntoWaveform;

                        TimeSpan startTime = new TimeSpan(0, 0, (int)startSecondsIntoWaveform);
                        TimeSpan durationTime = new TimeSpan(0, 0, (int)duration);

                        Debug.WriteLine("Start Time: " + startTime.ToString());
                        Debug.WriteLine("Duration Time: " + durationTime.ToString());

                        var waveformTicker = new DispatcherTimer();
                        waveformTicker.Tick += new EventHandler((object localsender, EventArgs locale) =>
                        {
                            if (waveform.isPlaying())
                            {
                                Debug.WriteLine("waveform is playing, so tick");
                                waveform.movePlay();
                            }
                            else
                            {
                                Debug.WriteLine("waveform stopped playing, so stop ticking");
                                (localsender as DispatcherTimer).Stop();
                            }
                        });
                        double secondsPerPixel = 1 / waveform.getPixelsPerSecond();
                        double nanoseconds = secondsPerPixel * 1000000000;
                        int ticks = (int)nanoseconds / 100;
                        Debug.WriteLine("Ticks: " + ticks);
                        waveformTicker.Interval = new TimeSpan(ticks);

                        var recordingTimer = new DispatcherTimer();
                        recordingTimer.Tick += new EventHandler((object localsender, EventArgs locale) =>
                        {
                            waveform.endPlay();
                            waveformTicker.Stop();
                            StopRecording();
                            (localsender as DispatcherTimer).Stop();
                            post_recording = true;
                            blackBack.Visibility = Visibility.Visible;
                            afterRecordCanvas.Visibility = Visibility.Visible;
                            switchModeToPlayback();
                            renderSegment(startOfSegment);
                        });
                        recordingTimer.Interval = durationTime;

                        AudioPlay.playForDuration(mainCanvas, songFilename, startTime, durationTime);
                        waveformTicker.Start();
                        waveform.startPlay();
                        startOfSegment = (int)(startTime.TotalSeconds * 30);
                        DanceSegment segment = routine.addDanceSegment(startOfSegment);
                        StartRecording(segment);
                        recordingTimer.Start();
                        return;
                    default:
                        return;
                }
            }
            if (post_recording)
            {
                Debug.WriteLine("Post-recording Speech detected: " + e.Result.Text.ToString());
                int startOfSegment = 0;
                switch (recognizedResultUpper)
                {
                    case "SAVE":
                    case "SAVES":
                    case "SAVED":
                    case "SAVING":
                    case "SLAVE":
                    case "WAVE":
                    case "STAY":
                    case "SAFE":
                    case "SHAVE":
                    case "STATE":
                        //keep_label.Visibility = Visibility.Visible;
                        hideMode();
                        waveform.deselectSegment();
                        post_recording = false;
                        blackBack.Visibility = Visibility.Collapsed;
                        afterRecordCanvas.Visibility = Visibility.Collapsed;
                        routine.save();
                        renderSegment(startOfSegment);
                        return;

                    case "CANCEL":
                    case "CANCELED":
                    case "CANCELS":
                    case "CHANCEL":
                    case "CHANCELLOR":
                    case "CATTLE":
                    case "SCANDAL":
                    case "COUNCIL":
                    case "CANCER":
                        //cancel_label.Visibility = Visibility.Visible;
                        post_recording = false;
                        blackBack.Visibility = Visibility.Collapsed;
                        afterRecordCanvas.Visibility = Visibility.Collapsed;
                        waveform.deselectSegment();
                        routine.deleteDanceSegment(segmentToRecordTo);
                        return;

                    case "REDO":
                    case "REDOES":
                    case "REVIEW":
                    case "ACCRUE":
                    case "ASKEW":
                    case "OUTDO":
                    case "RENEW":
                    case "UNDO":
                    case "CANOE":
                    case "IMBUE":
                        //redo_label.Visibility = Visibility.Visible;
                        post_recording = false;
                        blackBack.Visibility = Visibility.Collapsed;
                        afterRecordCanvas.Visibility = Visibility.Collapsed;
                        return;

                    case "PLAY":
                    case "PLAYS":
                    case "PLAYED":
                    case "BAY":
                    case "A":
                    case "PAY":
                    case "DISPLAY":
                    case "LAY":
                    case "DELAY":
                        //play_label.Visibility = Visibility.Visible;
                        post_recording = false;
                        blackBack.Visibility = Visibility.Collapsed;
                        afterRecordCanvas.Visibility = Visibility.Collapsed;
                        return;
                    //default:
                    //   return;
                }
            }
        }