Написать программу распознавания речи - Visual Basic .NET - Ответ 6325845

using System;
using System.Diagnostics;
using System.Linq;
using System.Windows;
using System.Windows.Media.Animation;
using System.Windows.Threading;
using Microsoft.Speech.AudioFormat;
using Microsoft.Speech.Recognition;
 
#if KINECT
using Microsoft.Kinect;
#endif
 
 
namespace KinectSpeechRecognize
{
    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        #region Fields
 
#if KINECT
        private KinectSensor _kinect;
#endif        
        private SpeechRecognitionEngine _speechRecognizer;
        private DispatcherTimer _readyTimer;
 
        #endregion // Fields
 
        #region .ctor
 
        public MainWindow()
        {
            InitializeComponent();
        }
 
        #endregion // .ctor
 
        #region Private methods
 
        private void InitializeSpeechEngine()
        {
            _speechRecognizer = CreateSpeechRecognizer();
 
            InitializeKinect();
#if !KINECT
            txtKinectStatus.Text = "kinect ISN't connected, default mic will be used";
#endif
 
            if (_speechRecognizer != null)
            {
                // NOTE: Need to wait 4 seconds for device to be ready to stream audio right after initialization
                _readyTimer = new DispatcherTimer();
                _readyTimer.Tick += ReadyTimerTick;
                _readyTimer.Interval = new TimeSpan(0, 0, 4);
                _readyTimer.Start();
 
                ReportSpeechStatus("initializing audio stream...");
            }
        }
 
        private void UninitializeSpeechEngine()
        {
#if KINECT
            if (_kinect != null)
            {
                _kinect.AudioSource.Stop();
                _kinect.Stop();
            }
#endif
            if (_speechRecognizer != null)
            {
                _speechRecognizer.RecognizeAsyncCancel();
                _speechRecognizer.RecognizeAsyncStop();
            }
 
            if (_readyTimer != null)
            {
                _readyTimer.Stop();
                _readyTimer = null;
            }
        }
 
        [Conditional("KINECT")]
        private void InitializeKinect()
        {
#if KINECT
            _kinect = KinectSensor.KinectSensors
                .Where(s => s.Status == KinectStatus.Connected)
                .FirstOrDefault();
 
            try
            {
                _kinect.Start();
                txtKinectStatus.Text = (_kinect != null) ? "kinect is connected" : "kinect ISN't connected, default mic will be used";
            }
            catch (Exception)
            {
                txtKinectStatus.Text = "kinect ISN't connected, default mic will be used";
            }
#endif
        }
 
        private SpeechRecognitionEngine CreateSpeechRecognizer()
        {
            RecognizerInfo ri = GetSpeechRecognizerInfo();
            if (ri == null)
            {
                MessageBox.Show(@"There was a problem initializing Speech Recognition. Ensure you have the Microsoft Speech SDK installed.", "Failed to load Speech SDK", MessageBoxButton.OK, MessageBoxImage.Error);
                this.Close();
                return null;
            }
 
            SpeechRecognitionEngine sre;
            try
            {
                sre = new SpeechRecognitionEngine(ri.Id);
            }
            catch
            {
                MessageBox.Show(@"There was a problem initializing Speech Recognition. Ensure you have the Microsoft Speech SDK installed and configured.", "Failed to load Speech SDK", MessageBoxButton.OK, MessageBoxImage.Error);
                this.Close();
                return null;
            }
 
            var commands = new Choices();
            commands.Add("up");
            commands.Add("down");
            commands.Add("left");
            commands.Add("right");
            commands.Add("exit");
 
            var gb = new GrammarBuilder(commands) { Culture = ri.Culture };
            //gb.Append(commands);
 
            // Create the actual Grammar instance, and then load it into the speech recognizer.
            sre.LoadGrammar(new Grammar(gb));
            sre.SpeechRecognized += SreSpeechRecognized;
            sre.SpeechHypothesized += SreSpeechHypothesized;
            sre.SpeechRecognitionRejected += SreSpeechRecognitionRejected;
 
            return sre;
        }
 
        private static RecognizerInfo GetSpeechRecognizerInfo()
        {
            return SpeechRecognitionEngine.InstalledRecognizers()
                .Where(ri => string.Equals(ri.Culture.Name, "en-US", StringComparison.InvariantCultureIgnoreCase))
                .FirstOrDefault();
        }
 
        private void ReadyTimerTick(object sender, EventArgs e)
        {
            Start();
            ReportSpeechStatus("ready to recognize speech!");
 
            _readyTimer.Stop();
            _readyTimer = null;
        }
 
        private void Start()
        {
#if KINECT
            if (_kinect != null)
            {
                var audioSource = _kinect.AudioSource;
                audioSource.BeamAngleMode = BeamAngleMode.Adaptive;
                var kinectStream = audioSource.Start();
 
                _speechRecognizer.SetInputToAudioStream(
                    kinectStream, new SpeechAudioFormatInfo(EncodingFormat.Pcm, 16000, 16, 1, 32000, 2, null));
            }
            else
            {
                _speechRecognizer.SetInputToDefaultAudioDevice();
            }
#else
            _speechRecognizer.SetInputToDefaultAudioDevice();
#endif            
            _speechRecognizer.RecognizeAsync(RecognizeMode.Multiple);
        }
 
        private void ReportSpeechStatus(string format, params object[] args)
        {
            ReportSpeechStatus(string.Format(format, args));
        }
 
        private void ReportSpeechStatus(string status)
        {
            Dispatcher.BeginInvoke(new Action(() => { txtCommand.Text = status; }), DispatcherPriority.Normal);
        }
 
        private void RejectSpeech(RecognitionResult result)
        {
            ReportSpeechStatus("rejected: {0} {1:0.000}", result == null ? string.Empty : result.Text.ToUpper(), result.Confidence);
        }
 
        private void ActivateStoryboard(string storyboardName)
        {
            var sb = this.Resources[storyboardName] as Storyboard;
            if (sb == null)
            {
                Debug.WriteLine("Storyboard with name '{0}' not found in window's resources.", storyboardName);
                return;
            }
 
            sb.Begin(this);
        }
 
        #endregion // Private methods
 
        #region Events handlers
 
        private void Window_Loaded(object sender, RoutedEventArgs e)
        {
            InitializeSpeechEngine();
        }
 
        private void Window_Unloaded(object sender, RoutedEventArgs e)
        {
            UninitializeSpeechEngine();
        }
 
        private void SreSpeechRecognized(object sender, SpeechRecognizedEventArgs e)
        {
            if (e.Result.Confidence < 0.7)
            {
                RejectSpeech(e.Result);
                return;
            }
 
            Action handler = null;
            switch (e.Result.Text.ToUpperInvariant())
            {
                case "UP":
                case "DOWN":
                case "LEFT":
                case "RIGHT":
                    handler = () => { ActivateStoryboard(e.Result.Text.ToUpperInvariant()); };
                    break;
                case "EXIT":
                    handler = () => { this.Close(); };
                    break;
                default:
                    break;
            }
 
            ReportSpeechStatus(string.Format("recognized: {0} {1:0.000}", e.Result.Text.ToUpper(), e.Result.Confidence));
 
            if (handler != null)
            {
                Dispatcher.BeginInvoke(handler, DispatcherPriority.Normal);
            }
        }
 
        private void SreSpeechHypothesized(object sender, SpeechHypothesizedEventArgs e)
        {
            ReportSpeechStatus("hypothesized: {0} {1:0.000}", e.Result.Text.ToUpper(), e.Result.Confidence);
        }
 
        private void SreSpeechRecognitionRejected(object sender, SpeechRecognitionRejectedEventArgs e)
        {
            RejectSpeech(e.Result);
        }
 
        #endregion // Events handlers
    }
}