基于vc++2008托管代码开发Windows Vista语音识别

废话少说看代码

#pragma once
#include "Window1.g.h"
#include "Resources.Designer.h"

using namespace System;
using namespace System::Collections::Generic;
using namespace System::Text;
using namespace System::Windows;
using namespace System::Windows::Controls;
using namespace System::Windows::Data;
using namespace System::Windows::Documents;
using namespace System::Windows::Input;
using namespace System::Windows::Media;
using namespace System::Windows::Media::Imaging;
using namespace System::Windows::Shapes;

using namespace System::Reflection;
using namespace System::Windows::Threading;
using namespace System::IO;
using namespace System::Xml;
using namespace System::Collections::ObjectModel;
using namespace System::ComponentModel;

using namespace System::Speech::Recognition;
using namespace System::Speech::Recognition::SrgsGrammar;
using namespace System::Speech::Synthesis;

namespace speechReco
{
/// <summary>
/// Interaction logic for Window1.xaml
/// </summary>

//ORIGINAL LINE: public partial class Window1 : System.Windows.Window
//INSTANT C++ TODO TASK: C++ does not support 'partial' types. You must manually combine the entire Window1 type in one place.
public ref class Window1 : System::Windows::Window
{
private:
SpeechRecognizer ^sharedRecognizer;
SpeechRecognitionEngine ^appRecognizer;
SrgsDocument ^sdCmnrules;

public:
Window1()
{
InitializeComponent();

sharedRecognizer = gcnew SpeechRecognizer();
sharedRecognizer->AudioLevelUpdated += gcnew EventHandler<AudioLevelUpdatedEventArgs^>(this, &Window1::sharedRecognizer_AudioLevelUpdated);
sharedRecognizer->AudioSignalProblemOccurred += gcnew EventHandler<AudioSignalProblemOccurredEventArgs^>(this, &Window1::sharedRecognizer_AudioSignalProblemOccurred);
sharedRecognizer->AudioStateChanged += gcnew EventHandler<AudioStateChangedEventArgs^>(this, &Window1::sharedRecognizer_AudioStateChanged);
sharedRecognizer->EmulateRecognizeCompleted += gcnew EventHandler<EmulateRecognizeCompletedEventArgs^>(this, &Window1::sharedRecognizer_EmulateRecognizeCompleted);
sharedRecognizer->LoadGrammarCompleted += gcnew EventHandler<LoadGrammarCompletedEventArgs^>(this, &Window1::sharedRecognizer_LoadGrammarCompleted);
sharedRecognizer->RecognizerUpdateReached += gcnew EventHandler<RecognizerUpdateReachedEventArgs^>(this, &Window1::sharedRecognizer_RecognizerUpdateReached);
sharedRecognizer->SpeechDetected += gcnew EventHandler<SpeechDetectedEventArgs^>(this, &Window1::sharedRecognizer_SpeechDetected);
sharedRecognizer->SpeechHypothesized += gcnew EventHandler<SpeechHypothesizedEventArgs^>(this, &Window1::sharedRecognizer_SpeechHypothesized);
sharedRecognizer->SpeechRecognitionRejected += gcnew EventHandler<SpeechRecognitionRejectedEventArgs^>(this, &Window1::sharedRecognizer_SpeechRecognitionRejected);
sharedRecognizer->SpeechRecognized += gcnew EventHandler<SpeechRecognizedEventArgs^>(this, &Window1::sharedRecognizer_SpeechRecognized);
sharedRecognizer->StateChanged += gcnew EventHandler<System::Speech::Recognition::StateChangedEventArgs^>(this, &Window1::sharedRecognizer_StateChanged);

//load SRGS library
array<System::Byte> ^ba = speechReco::Properties::Resources::cmnrules;
MemoryStream ^ms = gcnew MemoryStream(ba);
ms->Position = 0;
XmlReader ^xr = XmlReader::Create(ms);
sdCmnrules = gcnew SrgsDocument(xr);
//populate ComboBox
for each(SrgsRule ^rule in sdCmnrules->Rules)
{
if (rule->Scope == SrgsRuleScope::Public)
{
cbRules->Items->Add(rule->Id);
}
}
//default to integer rule
cbRules->SelectedValue = "integer";
cbRules->SelectionChanged += gcnew SelectionChangedEventHandler(this, &Window1::cbRules_SelectionChanged);

this->btnSharedColor->Click += gcnew RoutedEventHandler(this, &Window1::btnSharedColor_Click);
this->btnInProcColor->Click += gcnew RoutedEventHandler(this, &Window1::btnInProcColor_Click);
this->btnTapDictation->PreviewMouseLeftButtonDown += gcnew MouseButtonEventHandler(this, &Window1::btnTapDictation_PreviewMouseLeftButtonDown);
this->btnTapDictation->PreviewMouseLeftButtonUp += gcnew MouseButtonEventHandler(this, &Window1::btnTapDictation_PreviewMouseLeftButtonUp);
this->btnSrgs->Click += gcnew RoutedEventHandler(this, &Window1::btnSrgs_Click);
this->btnAdvGrammarBuilder->Click += gcnew RoutedEventHandler(this, &Window1::btnAdvGrammarBuilder_Click);
this->btnWavFile->Click += gcnew RoutedEventHandler(this, &Window1::btnWavFile_Click);
this->btnSynthPhonemes->Click += gcnew RoutedEventHandler(this, &Window1::btnSynthPhonemes_Click);
this->btnEnable->Click += gcnew RoutedEventHandler(this, &Window1::btnEnable_Click);
this->btnDisable->Click += gcnew RoutedEventHandler(this, &Window1::btnDisable_Click);
this->btnUnload->Click += gcnew RoutedEventHandler(this, &Window1::btnUnload_Click);
this->btnEmulate->Click += gcnew RoutedEventHandler(this, &Window1::btnEmulate_Click);
}

private:
void btnEmulate_Click(System::Object ^sender, RoutedEventArgs ^e)
{
//sharedRecognizer.EmulateRecognize("green");
sharedRecognizer->EmulateRecognizeAsync("green");
//sharedRecognizer.EmulateRecognize("stop listening");
}

void btnUnload_Click(System::Object ^sender, RoutedEventArgs ^e)
{
sharedRecognizer->UnloadAllGrammars();
}

void btnDisable_Click(System::Object ^sender, RoutedEventArgs ^e)
{
sharedRecognizer->Enabled = false;
}

void btnEnable_Click(System::Object ^sender, RoutedEventArgs ^e)
{
sharedRecognizer->Enabled = true;
}

System::String ^recoPhonemes;
void btnSynthPhonemes_Click(System::Object ^sender, RoutedEventArgs ^e)
{
//this is a trick to figure out phonemes used by synthesis engine

//txt to wav
MemoryStream ^audioStream = gcnew MemoryStream();
SpeechSynthesizer ^synth = gcnew SpeechSynthesizer();
synth->SetOutputToWaveStream(audioStream);
PromptBuilder ^pb = gcnew PromptBuilder();
pb->AppendBreak(PromptBreak::ExtraSmall); //'e' wont be recognized if this is large, or non-existent?
synth->Speak(pb);
System::String ^textToSpeak = this->txtSynthTxt->Text->Trim();
synth->Speak(textToSpeak);
//synth.Speak(pb);
synth->SetOutputToNull();
audioStream->Position = 0;

//now wav to txt (for reco phonemes)
recoPhonemes = System::String::Empty;
GrammarBuilder ^gb = gcnew GrammarBuilder(textToSpeak);
Grammar ^g = gcnew Grammar(gb); //TODO the hard letters to recognize are 'g' and 'e'
SpeechRecognitionEngine ^reco = gcnew SpeechRecognitionEngine();
reco->SpeechHypothesized += gcnew EventHandler<SpeechHypothesizedEventArgs^>(this, &Window1::reco_SpeechHypothesized);
reco->SpeechRecognitionRejected += gcnew EventHandler<SpeechRecognitionRejectedEventArgs^>(this, &Window1::reco_SpeechRecognitionRejected);
reco->UnloadAllGrammars(); //only use the one word grammar
reco->LoadGrammar(g);
reco->SetInputToWaveStream(audioStream);
RecognitionResult ^rr = reco->Recognize();
reco->SetInputToNull();
if (rr != nullptr)
{
recoPhonemes = StringFromWordArray(rr->Words, WordType::Pronunciation);
}
txtRecoPho->Text = recoPhonemes;
}

void reco_SpeechRecognitionRejected(System::Object ^sender, SpeechRecognitionRejectedEventArgs ^e)
{
recoPhonemes = StringFromWordArray(e->Result->Words, WordType::Pronunciation);
}

void reco_SpeechHypothesized(System::Object ^sender, SpeechHypothesizedEventArgs ^e)
{
recoPhonemes = StringFromWordArray(e->Result->Words, WordType::Pronunciation);
}

void btnWavFile_Click(System::Object ^sender, RoutedEventArgs ^e)
{
sharedRecognizer->Enabled = false;

appRecognizer = gcnew SpeechRecognitionEngine();
appRecognizer->SetInputToWaveFile("spoken.wav");
appRecognizer->LoadGrammar(gcnew DictationGrammar());
RecognitionResult ^rr = appRecognizer->Recognize();
appRecognizer->SetInputToNull();
if (rr == nullptr)
{
MessageBox::Show("null result?");
}
else
{
//NOTE in-process recognir cannot send feedback to microphone bar
//SpeechUI.SendTextFeedback(rr, rr.Text, true);

//show phoneme result
System::String ^phonemes = StringFromWordArray(rr->Words, WordType::Pronunciation);
txtRecoPho->Text = phonemes;

//show text result
MessageBox::Show(rr->Text);
}
delete appRecognizer;
}

public:
enum class WordType
{
Text,
Normalized = Text,
Lexical,
Pronunciation
};

public:
static System::String ^StringFromWordArray(ReadOnlyCollection<RecognizedWordUnit^> ^words, WordType type)
{
System::String ^text = "";
for each (RecognizedWordUnit ^word in words)
{
System::String ^wordText = "";
if (type == WordType::Text || type == WordType::Normalized)
{
wordText = word->Text;
}
else if (type == WordType::Lexical)
{
wordText = word->LexicalForm;
}
else if (type == WordType::Pronunciation)
{
wordText = word->Pronunciation;
}
else
{
throw gcnew InvalidEnumArgumentException(System::String::Format("[0}: is not a valid input", type));
}
//Use display attribute

if ((word->DisplayAttributes & DisplayAttributes::OneTrailingSpace) != 0)
{
wordText += " ";
}
if ((word->DisplayAttributes & DisplayAttributes::TwoTrailingSpaces) != 0)
{
wordText += " ";
}
if ((word->DisplayAttributes & DisplayAttributes::ConsumeLeadingSpaces) != 0)
{
wordText = wordText->TrimStart();
}
if ((word->DisplayAttributes & DisplayAttributes::ZeroTrailingSpaces) != 0)
{
wordText = wordText->TrimEnd();
}

text += wordText;

}
return text;
}

private:
void btnAdvGrammarBuilder_Click(System::Object ^sender, RoutedEventArgs ^e)
{
sharedRecognizer->Enabled = true;
sharedRecognizer->UnloadAllGrammars();

//from http://msdn.microsoft.com/msdnmag/issues/06/01/speechinWindowsVista/#S5
//[I'd like] a [<size>] [<crust>] [<topping>] pizza [please]

//build the core set of choices
Choices ^sizes = gcnew Choices("small", "regular", "large");
Choices ^crusts = gcnew Choices("thin crust", "thick crust");
Choices ^toppings = gcnew Choices("vegetarian", "pepperoni", "cheese");

SemanticResultKey ^srkSize = gcnew SemanticResultKey("size", sizes->ToGrammarBuilder());
SemanticResultKey ^srkCrust = gcnew SemanticResultKey("crust", crusts->ToGrammarBuilder());
SemanticResultKey ^srkTopping = gcnew SemanticResultKey("topping", toppings->ToGrammarBuilder());
SemanticResultValue ^srvSize = gcnew SemanticResultValue(srkSize, "regular");
SemanticResultValue ^srvCrust = gcnew SemanticResultValue(srkCrust, "thick crust");

//build the permutations of choices...
//choose all three
GrammarBuilder ^sizeCrustTopping = gcnew GrammarBuilder();
//sizeCrustTopping.AppendChoices(sizes, "size");
//sizeCrustTopping.AppendChoices(crusts, "crust");
//sizeCrustTopping.AppendChoices(toppings, "topping");
sizeCrustTopping->Append(srkSize);
sizeCrustTopping->Append(srkCrust);
sizeCrustTopping->Append(srkTopping);

//choose size and topping, and assume thick crust
GrammarBuilder ^sizeAndTopping = gcnew GrammarBuilder();
//sizeAndTopping.AppendChoices(sizes, "size");
//sizeAndTopping.AppendChoices(toppings, "topping");
//sizeAndTopping.AppendResultKeyValue("crust", "thick crust");
sizeAndTopping->Append(srkSize);
sizeAndTopping->Append(srkTopping);
//TODO how to set default semantic value for "crust"?
//sizeAndTopping.Append(srvCrust);
//sizeAndTopping.Append(new SemanticResultValue(crusts.ToGrammarBuilder(), "thick crust"));
//sizeAndTopping.Append(new SemanticResultValue("crust", "thick crust"));
//sizeAndTopping.Append(new SemanticResultValue("thick crust"));
//sizeAndTopping.Append(new SemanticResultKey("crust", "thick crust"));

//choose topping only, and assume the rest
GrammarBuilder ^toppingOnly = gcnew GrammarBuilder();
//toppingOnly.AppendChoices(toppings, "topping");
//toppingOnly.AppendResultKeyValue("size", "regular");
//toppingOnly.AppendResultKeyValue("crust", "thick crust");
toppingOnly->Append(srkTopping);
//TODO how to set default semantic value for "size" and "crust"?
//toppingOnly.Append(srvSize);
//toppingOnly.Append(srvCrust);
//toppingOnly.Append(new SemanticResultKey("size", "regular"));
//toppingOnly.Append(new SemanticResultKey("crust", "thick crust"));

//assemble the permutations
Choices ^permutations = gcnew Choices();
permutations->Add(sizeCrustTopping);
permutations->Add(sizeAndTopping);
permutations->Add(toppingOnly);

//now build the complete pattern...
GrammarBuilder ^pizzaRequest = gcnew GrammarBuilder();
//pre-amble "[I'd like] a"
pizzaRequest->Append(gcnew Choices("I'd like a", "a"));
//permutations "[<size>] [<crust>] [<topping>]"
pizzaRequest->Append(permutations);
//post-amble "pizza [please]"
pizzaRequest->Append(gcnew Choices("pizza", "pizza please"));
System::String ^debug = pizzaRequest->DebugShowPhrases;

//create the pizza grammar
Grammar ^pizzaGrammar = gcnew Grammar(pizzaRequest);

//attach the event handler
pizzaGrammar->SpeechRecognized += gcnew EventHandler<SpeechRecognizedEventArgs^>(this, &Window1::pizzaGrammar_SpeechRecognized);

//load the grammar into the recognizer
sharedRecognizer->LoadGrammar(pizzaGrammar);

}

void pizzaGrammar_SpeechRecognized(System::Object ^sender, SpeechRecognizedEventArgs ^e)
{
StringBuilder ^resultString = gcnew StringBuilder();
resultString->Append("Raw text result: ");
resultString->AppendLine(e->Result->Text);
resultString->Append("Size: ");
resultString->AppendLine(e->Result->Semantics["size"]->Value->ToString());
resultString->Append("Crust: ");
resultString->AppendLine(e->Result->Semantics["crust"]->Value->ToString());
resultString->Append("Topping: ");
resultString->AppendLine(e->Result->Semantics["topping"]->Value->ToString());
MessageBox::Show(resultString->ToString());
}

void cbRules_SelectionChanged(System::Object ^sender, SelectionChangedEventArgs ^e)
{
//TODO
}

void btnSrgs_Click(System::Object ^sender, RoutedEventArgs ^e)
{
sharedRecognizer->Enabled = true;
sharedRecognizer->UnloadAllGrammars();

System::String ^ruleName = safe_cast<System::String^>(cbRules->SelectedValue);
//SrgsRule rule = sdCmnrules.Rules[ruleName];

Grammar ^grammarSrgs = gcnew Grammar(sdCmnrules, ruleName);
grammarSrgs->SpeechRecognized += gcnew EventHandler<SpeechRecognizedEventArgs^>(this, &Window1::grammarSrgs_SpeechRecognized);

sharedRecognizer->LoadGrammar(grammarSrgs);
MessageBox::Show("listening for user input based on the selected rule : " + ruleName);
}

void grammarSrgs_SpeechRecognized(System::Object ^sender, SpeechRecognizedEventArgs ^e)
{
//send text to microphone bar
SpeechUI::SendTextFeedback(e->Result, e->Result->Text, true);
//send actual numeric value to TextBox on form
if (e->Result->Semantics->Value != nullptr)
{
this->Dispatcher->Invoke(DispatcherPriority::Render, gcnew UpdateTxtRecoDelegate(UpdateTextReco), e->Result->Semantics->Value->ToString());
}
}

void btnTapDictation_PreviewMouseLeftButtonDown(System::Object ^sender, MouseButtonEventArgs ^e)
{
sharedRecognizer->Enabled = false;

dictationResult = System::String::Empty;
appRecognizer = gcnew SpeechRecognitionEngine();
appRecognizer->SetInputToDefaultAudioDevice();
appRecognizer->SpeechRecognized += gcnew EventHandler<SpeechRecognizedEventArgs^>(this, &Window1::appRecognizer_SpeechRecognized);
DictationGrammar ^dg;
if (cbSpelling->IsChecked == false)
{
dg = gcnew DictationGrammar();
}
else
{
dg = gcnew DictationGrammar("grammar:dictation#spelling");
}
appRecognizer->LoadGrammar(dg);
appRecognizer->RecognizeAsync(RecognizeMode::Multiple);
}

System::String ^dictationResult;
void appRecognizer_SpeechRecognized(System::Object ^sender, SpeechRecognizedEventArgs ^e)
{
//on UI thread
dictationResult += e->Result->Text;
txtReco->Text = dictationResult;
}

void btnTapDictation_PreviewMouseLeftButtonUp(System::Object ^sender, MouseButtonEventArgs ^e)
{
appRecognizer->RecognizeAsyncStop();
delete appRecognizer;
}

void btnInProcColor_Click(System::Object ^sender, RoutedEventArgs ^e)
{
sharedRecognizer->Enabled = false;

Choices ^cColor = GetColorChoices();

GrammarBuilder ^gb = gcnew GrammarBuilder(cColor);
Grammar ^grammarColors = gcnew Grammar(gb);
grammarColors->SpeechRecognized += gcnew EventHandler<SpeechRecognizedEventArgs^>(this, &Window1::grammarColors_SpeechRecognized);

appRecognizer = gcnew SpeechRecognitionEngine();
appRecognizer->SetInputToDefaultAudioDevice();
appRecognizer->LoadGrammar(grammarColors);
appRecognizer->LoadGrammar(gcnew DictationGrammar());
appRecognizer->RecognizeAsync(RecognizeMode::Multiple);

MessageBox::Show("listening for you to say a color (e.g. Green)");
}

Choices ^GetColorChoices()
{
//build a grammar list of colors
Choices ^cColor = gcnew Choices();

Type ^t = Colors::typeid;
array<MemberInfo^> ^mia = t->GetMembers(BindingFlags::Public | BindingFlags::Static);
for each (MemberInfo ^mi in mia)
{
if (mi->Name->StartsWith("get_") == true)
continue;
cColor->Add(mi->Name);
}

return cColor;
}

void btnSharedColor_Click(System::Object ^sender, RoutedEventArgs ^e)
{
sharedRecognizer->Enabled = true;
sharedRecognizer->UnloadAllGrammars();

Choices ^cColor = GetColorChoices();

GrammarBuilder ^gb = gcnew GrammarBuilder(cColor);
Grammar ^grammarColors = gcnew Grammar(gb);
grammarColors->SpeechRecognized += gcnew EventHandler<SpeechRecognizedEventArgs^>(this, &Window1::grammarColors_SpeechRecognized);

sharedRecognizer->LoadGrammar(grammarColors);
MessageBox::Show("listening for you to say a color (e.g. Green)");
}

void grammarColors_SpeechRecognized(System::Object ^sender, SpeechRecognizedEventArgs ^e)
{
//not on UI thread
//txtReco.Text = e.Result.Text;
//need to use Dispatcher to get back on UI thread

//TODO cannot convert from 'anonymous method' to 'System.Delegate' ... WTF?
//this.Dispatcher.Invoke(DispatcherPriority.Render,
// delegate()
// {
// txtReco.Text = e.Result.Text;
// });

//http://romanski.livejournal.com/1761.html
//INSTANT C++ TODO TASK: Anonymous methods are not converted by Instant C++ C# Edition if local variables of the outer method are referenced within the anonymous method:
this->Dispatcher->Invoke(DispatcherPriority::Render, (System::Windows::Forms::MethodInvoker) delegate(System::Object^ sender, System::EventArgs e));
{
txtReco->Text = e->Result->Text;
}

//this.Dispatcher.Invoke(DispatcherPriority.Render, new UpdateTxtRecoDelegate(UpdateTextReco), e.Result.Text);
}

delegate void UpdateTxtRecoDelegate(System::String ^arg);
public:
void UpdateTextReco(System::String ^arg)
{
txtReco->Text = arg;
}

#pragma region SHARED_RECOGNIZER_EVENTS
private:
void sharedRecognizer_StateChanged(System::Object ^sender, System::Speech::Recognition::StateChangedEventArgs ^e)
{
System::Console::WriteLine("StateChanged : " + e->RecognizerState.ToString());
}

void sharedRecognizer_SpeechRecognized(System::Object ^sender, SpeechRecognizedEventArgs ^e)
{
//on UI thread
System::Console::WriteLine("SpeechRecognized : " + e->Result->Text);
//txtReco.Text = e.Result.Text;
}

void sharedRecognizer_SpeechRecognitionRejected(System::Object ^sender, SpeechRecognitionRejectedEventArgs ^e)
{
System::Console::WriteLine("SpeechRecognitionRejected : " + e->Result->Text);
}

void sharedRecognizer_SpeechHypothesized(System::Object ^sender, SpeechHypothesizedEventArgs ^e)
{
System::Console::WriteLine("SpeechHypothesized : " + e->Result->Text);
}

void sharedRecognizer_SpeechDetected(System::Object ^sender, SpeechDetectedEventArgs ^e)
{
System::Console::WriteLine("SpeechDetected : " + e->AudioPosition.TotalMilliseconds.ToString());
}

void sharedRecognizer_RecognizerUpdateReached(System::Object ^sender, RecognizerUpdateReachedEventArgs ^e)
{
System::Console::WriteLine("RecognizerUpdateReached : " + e->AudioPosition.TotalMilliseconds.ToString());
}

void sharedRecognizer_LoadGrammarCompleted(System::Object ^sender, LoadGrammarCompletedEventArgs ^e)
{
System::Console::WriteLine("LoadGrammarCompleted : " + e->Grammar->Name);
}

void sharedRecognizer_EmulateRecognizeCompleted(System::Object ^sender, EmulateRecognizeCompletedEventArgs ^e)
{
if (e->Result != nullptr)
{
System::Console::WriteLine("EmulateRecognizeCompleted : " + e->Result->Text);
}
else
{
System::Console::WriteLine("EmulateRecognizeCompleted : null result");
}
}

void sharedRecognizer_AudioStateChanged(System::Object ^sender, AudioStateChangedEventArgs ^e)
{
System::Console::WriteLine("AudioStateChanged : " + e->AudioState.ToString());
}

void sharedRecognizer_AudioSignalProblemOccurred(System::Object ^sender, AudioSignalProblemOccurredEventArgs ^e)
{
System::Console::WriteLine("AudioSignalProblemOccurred : " + e->AudioSignalProblem.ToString());
}

void sharedRecognizer_AudioLevelUpdated(System::Object ^sender, AudioLevelUpdatedEventArgs ^e)
{
//System.Console.WriteLine("AudioLevelUpdated : " + e.AudioLevel.ToString());
}
#pragma endregion

};
}

需要的留下eMAIL，我给大家发