public void Transcribe(MediaSegment segment)
{
using (var engine = new SpeechRecognitionEngine())
{
engine.LoadGrammar(new DictationGrammar());
engine.SetInputToWaveFile(segment.File.FullName);
var result = engine.Recognize();
var metaDatum = new Metadata();
metaDatum.Start = result.Audio.AudioPosition.TotalMilliseconds + segment.OffsetMs;
metaDatum.End = metaDatum.Start + segment.DurationMs;
metaDatum.EngineMetadata = new SpeechResults
{
Text = result.Text,
Confidence = result.Confidence
};
_concurrentDictionary.AddOrUpdate(segment.FileId, new List<Metadata> {metaDatum}, (x, y) =>
{
y.Add(metaDatum);
return y;
});
}
}
/// <summary>
/// Recognize method has not handle exception if audio is not in video file and it goes in while loop. to overcome this join main thread if it not returns in specific time
/// </summary>
/// <param name="audioFilePath"></param>
/// <param name="noOfAudioFiles"></param>
/// <param name="recognizer"></param>
private void codeBlock(string audioFilePath, int noOfAudioFiles, SpeechRecognitionEngine recognizer)
{
try
{
recognizer.SetInputToWaveFile(audioFilePath);
RecognitionResult result = recognizer.Recognize(timeSpan);
audioContentMessage += "\r\n" + result.Text;
}
catch (Exception)
{
}
}
public void StartDesign()
{
//In Process SpeewchRecognizer
SpeechRecognitionEngine recognizer = new SpeechRecognitionEngine();
recognizer.LoadGrammarCompleted += new EventHandler<LoadGrammarCompletedEventArgs>(LoadGrammarCompleted);
recognizer.SpeechRecognized += new EventHandler<SpeechRecognizedEventArgs>(SpeechRecognized);
recognizer.SpeechRecognitionRejected += new EventHandler<SpeechRecognitionRejectedEventArgs>(SpeechRejected);
recognizer.SetInputToDefaultAudioDevice();
GrammarBuilder clear = new GrammarBuilder("Clear");
GrammarBuilder insert = new GrammarBuilder("Insert");
Choices gates = new Choices(new string[] { "and", "or", "not", "ex or", "nor", "nand" });
Choices columns = new Choices(new string[] { "one", "too", "three", "four", "five", "six", "seven", "eight" });
Choices rows = new Choices(new string[] { "one", "too", "three", "four", "five" });
Choices orientation = new Choices(new string[] { "left", "right", "up", "down" });
insert.Append(gates);
insert.Append(columns);
insert.Append(rows);
insert.Append("towards");
insert.Append(orientation);
GrammarBuilder connect = new GrammarBuilder("Connect");
connect.Append("output");
connect.Append(columns);
connect.Append(rows);
connect.Append("to");
connect.Append("input");
connect.Append(columns);
connect.Append(rows);
Grammar _clear_grammar = new Grammar(clear);
Grammar _insert_grammar = new Grammar(insert);
Grammar _connect_grammar = new Grammar(connect);
recognizer.LoadGrammarAsync(_clear_grammar);
recognizer.LoadGrammarAsync(_insert_grammar);
recognizer.LoadGrammarAsync(_connect_grammar);
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new Form1());
//recognizer.RecognizeAsync(RecognizeMode.Multiple);
while (true)
{
recognizer.Recognize();
}
}
public override void Loop()
{
return;
using (var recognizer = new SpeechRecognitionEngine(new System.Globalization.CultureInfo("en-US")))
{
recognizer.LoadGrammar(new DictationGrammar());
while (true)
{
recognizer.SetInputToDefaultAudioDevice();
var result = recognizer.Recognize();
if(result == null) continue;
Handle(result.Text);
}
}
}
protected void decode()
{
try
{
SpeechRecognitionEngine SpeechRecognitionEngine = new SpeechRecognitionEngine();
DictationGrammar DictationGrammer = new DictationGrammar();
SpeechRecognitionEngine.LoadGrammar(DictationGrammer);
SpeechRecognitionEngine.SetInputToWaveFile(Input);
RecognitionResult Result = SpeechRecognitionEngine.Recognize();
mOutput = Result.Text;
}
catch (Exception E)
{
MessageBox.Show(E.Message);
}
}
public string RecognizeSpeech(byte[] speechToParse, int sampleRate)
{
SpeechRecognitionEngine sre = new SpeechRecognitionEngine();
if (_grammar == null)
InitializeGrammar();
sre.LoadGrammar(_grammar);
MemoryStream ms = new MemoryStream(speechToParse);
var formatInfo = new SpeechAudioFormatInfo(sampleRate, AudioBitsPerSample.Sixteen, AudioChannel.Mono);
sre.SetInputToAudioStream(ms, formatInfo);
var result = sre.Recognize();
ms = null;
if (result == null)
return "Unable to recognize speech";
else
return result.Text;
}
void Record()
{
KinectAudioSource source = kinectSensor.AudioSource;
Func<RecognizerInfo, bool> matchingFunc = r =>
{
string value;
r.AdditionalInfo.TryGetValue("Kinect", out value);
return
"True".Equals(value, StringComparison.InvariantCultureIgnoreCase) &&
"en-US".Equals(r.Culture.Name, StringComparison.InvariantCultureIgnoreCase);
};
var recognizerInfo = SpeechRecognitionEngine.InstalledRecognizers().Where(matchingFunc).FirstOrDefault();
if (recognizerInfo == null)
return;
speechRecognitionEngine = new SpeechRecognitionEngine(recognizerInfo.Id);
var gb = new GrammarBuilder { Culture = recognizerInfo.Culture };
gb.Append(choices);
var grammar = new Grammar(gb);
speechRecognitionEngine.LoadGrammar(grammar);
source.AutomaticGainControlEnabled = false;
source.BeamAngleMode = BeamAngleMode.Adaptive;
using (Stream sourceStream = source.Start())
{
speechRecognitionEngine.SetInputToAudioStream(sourceStream,
new SpeechAudioFormatInfo(EncodingFormat.Pcm, 16000, 16, 1, 32000, 2, null));
while (isRunning)
{
RecognitionResult result = speechRecognitionEngine.Recognize();
if (result != null && OrderDetected != null && result.Confidence > 0.7)
OrderDetected(result.Text);
}
}
}
private void button1_Click(object sender, EventArgs e)
{
SpeechRecognitionEngine recognizer = new SpeechRecognitionEngine();
Grammar dictationGrammar = new DictationGrammar();
recognizer.LoadGrammar(dictationGrammar);
try
{
button1.Text = "Speak Now";
recognizer.SetInputToDefaultAudioDevice();
RecognitionResult result = recognizer.Recognize();
button1.Text = result.Text;
}
catch (InvalidOperationException exception)
{
button1.Text = String.Format("Could not recognize input from default aduio device. Is a microphone or sound card available?\r\n{0} - {1}.", exception.Source, exception.Message);
}
finally
{
recognizer.UnloadAllGrammars();
}
}
static void Main(string[] args)
{
NaoSpeechRecognitionEntities db = new NaoSpeechRecognitionEntities();
var userInput = db.UserInputs.ToList();
//List<string> userReplies = new List<string>();
Choices userReplies = new Choices();
foreach (var reply in userInput)
{
userReplies.Add(reply.Reply);
}
sre = new SpeechRecognitionEngine();
GrammarBuilder gb = new GrammarBuilder();
gb.Append(userReplies);
Grammar g = new Grammar(gb);
sre.LoadGrammar(g);
sre.SpeechRecognized += new EventHandler<SpeechRecognizedEventArgs>(sre_SpeechRecognized);
sre.SetInputToDefaultAudioDevice();
// Start recognition.
sre.Recognize();
Console.ReadKey();
}
private void button1_Click(object sender, EventArgs e)
{
SpeechRecognitionEngine myvoice = new SpeechRecognitionEngine();
Grammar dictationGrammar = new DictationGrammar();
myvoice.LoadGrammar(dictationGrammar);
try
{
myvoice.SetInputToDefaultAudioDevice();
RecognitionResult result = myvoice.Recognize();
textBox1.AppendText(result.Text);
}
catch (Exception)
{
MessageBox.Show("No audio input device is present or active. Connect a microphone and try again.");
}
finally
{
myvoice.UnloadAllGrammars();
}
}
// recognition speech button
private void button1_Click(object sender, EventArgs e)
{
SpeechRecognitionEngine s = new SpeechRecognitionEngine();
Grammar words = new DictationGrammar();
s.LoadGrammar(words);
try
{
s.SetInputToDefaultAudioDevice();
RecognitionResult result = s.Recognize();
textBox1.Text = result.Text;
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
finally
{
s.UnloadAllGrammars();
}
}
private void speechButton_Click(object sender, EventArgs e)
{
recognitionEngine = new SpeechRecognitionEngine();
dictionaryGrammar = new DictationGrammar();
recognitionEngine.LoadGrammar(dictionaryGrammar);
try
{
recognitionEngine.SetInputToDefaultAudioDevice();
result = recognitionEngine.Recognize();
outputTextBox.Text = result.Text;
}
catch (InvalidOperationException exception)
{
MessageBox.Show("Could not recognize input from default aduio device. Is a microphone or sound card available?\r\n " + exception.Source + " - " + exception.Message);
}
finally
{
recognitionEngine.UnloadAllGrammars();
}
}
public Galerie()
{
InitializeComponent();
DemarrerKinect();
/* Gestion du timer */
timer.Interval = TimeSpan.FromSeconds(1);
timer.Tick += timer_Tick;
timer.Start();
/* Affichage de la première photo */
dossierPhotos = new DirectoryInfo("Images");
fichiersPhotos = dossierPhotos.GetFiles();
imgPhoto.Source = new BitmapImage(new Uri(fichiersPhotos[indexPhoto].FullName));
/* Gestion de la reconnaissance vocale */
//On entre une liste de mots a reconnaitre (ici nous avons rajouter un mot pour que la reconnaissance soit un peu plus précise, plus il y a de mots plus elle est précise
Choices choixDeMots = new Choices(new string[] { "licorne", "menu" });
Grammar grammaire = new Grammar(new GrammarBuilder(choixDeMots));
try
{
//On met à jour la reconnaissance
engine.RequestRecognizerUpdate();
//On lui attribue les mots a reconnaitre
engine.LoadGrammar(grammaire);
//On crée un événement pour quand un des mots de la liste est reconnu
engine.SpeechRecognized += engine_SpeechRecognized;
//On définit l'entrée audio par défaut
engine.SetInputToDefaultAudioDevice();
//On lance la reconnaissance en asynchrone
engine.RecognizeAsync(RecognizeMode.Multiple);
engine.Recognize();
}
catch
{
return;
}
}
private void button2_Click(object sender, EventArgs e)
{
SpeechRecognitionEngine engineSpeech = new SpeechRecognitionEngine();
Grammar gram = new DictationGrammar();
engineSpeech.LoadGrammar(gram);
try
{
engineSpeech.SetInputToDefaultAudioDevice();
RecognitionResult result = engineSpeech.Recognize();
label1.Text = result.Text;
textBox1.Text = result.Text;
button1_Click(new Object(),new EventArgs());
}
catch (Exception)
{
//Do nothing
}
finally
{
engineSpeech.UnloadAllGrammars();
}
}
public static Tuple <String, String> dictateSystem(SpeechRecognitionEngine recognitionEngine, List <string> trackedSystems)
{
RecognitionResult result = recognitionEngine.Recognize();
double topPickConfidence = 0.00;
string topPickSystem = null;
string topPickPhonetic = null;
if (result == null)
{
Debug.Write("dictate system: No system matched");
return(Tuple.Create <String, String>(null, null));
}
if (result.Alternates != null)
{
foreach (RecognizedPhrase phrase in result.Alternates)
{
double confidence = (double)phrase.Confidence;
var grammar = phrase.Grammar.Name;
var rule = phrase.Grammar.RuleName;
var semantic = phrase.Semantics.Value;
if (trackedSystems.Contains(phrase.Text))
{
confidence = confidence + (double)0.05;
Debug.Write("Bumping up " + phrase.Text + "by 5% confidence");
}
if (confidence > topPickConfidence)
{
topPickConfidence = confidence;
topPickSystem = semantic.ToString();
topPickPhonetic = phrase.Text.ToString();
}
Debug.Write("dictateSystem: Possible system " + semantic + " (" + phrase.Confidence.ToString() + ", " + phrase.Text + ")");
}
return(Tuple.Create <String, String>(topPickSystem, topPickPhonetic));
}
return(Tuple.Create <String, String>(null, null));
}
private void start()
{
Choices sList = new Choices();
sList.Add(new string[] { "hello", "find", "start", "monitoring", "login", "exit", "close", "quit", "zero", "one", "uno", "two", "three", "four", "five", "six", "clear", "cancer", "virus", "bacteria", "broken", "leg", "read" });
Grammar gr = new Grammar(new GrammarBuilder(sList));
try
{
sRecognize.RequestRecognizerUpdate();
sRecognize.LoadGrammar(gr);
sRecognize.SpeechRecognized += sRecognize_SpeechRecognized;
sRecognize.SetInputToDefaultAudioDevice();
sRecognize.RecognizeAsync(RecognizeMode.Multiple);
sRecognize.Recognize();
}
catch
{
return;
}
}
private void btnkonus_Click(object sender, EventArgs e)
{
try
{
RecognitionResult res = sr.Recognize();
if (res != null)
{
txtyazi.Text += "\ncontent:" + res.Text + "\n";
txtyazi.Text += "Translation:" + TranslateText(res.Text, cbdil1.Text, cbdil2.Text);
txtyazi.Text += "\n";
txtyazi.Text += "\nThis program is a gift";
SpVoice oku = new SpVoice();
oku.Speak(txtyazi.Text, SpeechVoiceSpeakFlags.SVSFDefault);
}
else
{
txtyazi.Text += "\nTry again.";
}
}
catch (Exception)
{ txtyazi.Text += "\nAn error occurred, please try again."; }
}
private void VoiceToText()
{
SpeechRecognitionEngine recognizer = new SpeechRecognitionEngine();
Grammar dictationGrammar = new DictationGrammar();
recognizer.LoadGrammar(dictationGrammar);
if (checkBox1.Checked == true)
{
recognizer.SetInputToDefaultAudioDevice();
}
else
{
recognizer.SetInputToWaveFile(@"C:\Users\hardy\source\repos\Catherine\Catherine\bin\Debug\Sound_File.wav");
}
RecognitionResult result = recognizer.Recognize();
recognizer.UnloadAllGrammars();
string a = String.Format($"({DateTime.Now}) User said: {result.Text}\n", Dialog_box.Text);
this.Dialog_box.Text += a;
}
private void btnRecognize_Click(object sender, EventArgs e)
{
try
{
Choices sList = new Choices();
sList.Add(new string[] { "c#", "hello", "how", "are", "you" });
GrammarBuilder gBuilder = new GrammarBuilder();
gBuilder.Append(sList);
Grammar gr = new Grammar(gBuilder);
speechRec.RequestRecognizerUpdate();
speechRec.LoadGrammar(gr);
speechRec.SpeechRecognized += new EventHandler <SpeechRecognizedEventArgs>(SpeechRec_SpeechRecognized);
speechRec.SetInputToDefaultAudioDevice();
speechRec.RecognizeAsync(RecognizeMode.Multiple);
speechRec.Recognize();
}
catch
{
return;
}
}
private void button1_Click(object sender, EventArgs e)
{
SpeechRecognitionEngine recognizer = new SpeechRecognitionEngine();
Grammar dictationGrammar = new DictationGrammar();
recognizer.LoadGrammar(dictationGrammar);
try
{
ViewBag.Text = "Speak Now";
recognizer.SetInputToDefaultAudioDevice();
RecognitionResult result = recognizer.Recognize();
ViewBag.Text = result.Text;
}
catch (InvalidOperationException exception)
{
ViewBag.Text = String.Format("Could not recognize input from default aduio device. Is a microphone or sound card available?\r\n{0} - {1}.", exception.Source, exception.Message);
}
finally
{
recognizer.UnloadAllGrammars();
}
}
public static string GetPronunciationFromText(string MyWord)
{
//this is a trick to figure out phonemes used by synthesis engine
//txt to wav
using (MemoryStream audioStream = new MemoryStream())
{
using (SpeechSynthesizer synth = new SpeechSynthesizer())
{
synth.SetOutputToWaveStream(audioStream);
PromptBuilder pb = new PromptBuilder();
//pb.AppendBreak(PromptBreak.ExtraSmall); //'e' wont be recognized if this is large, or non-existent?
//synth.Speak(pb);
synth.Speak(MyWord);
//synth.Speak(pb);
synth.SetOutputToNull();
audioStream.Position = 0;
//now wav to txt (for reco phonemes)
recoPhonemes = String.Empty;
GrammarBuilder gb = new GrammarBuilder(MyWord);
Grammar g = new Grammar(gb); //TODO the hard letters to recognize are 'g' and 'e'
SpeechRecognitionEngine reco = new SpeechRecognitionEngine();
reco.SpeechHypothesized += new EventHandler <SpeechHypothesizedEventArgs>(reco_SpeechHypothesized);
reco.SpeechRecognitionRejected += new EventHandler <SpeechRecognitionRejectedEventArgs>(reco_SpeechRecognitionRejected);
reco.UnloadAllGrammars(); //only use the one word grammar
reco.LoadGrammar(g);
reco.SetInputToWaveStream(audioStream);
RecognitionResult rr = reco.Recognize();
reco.SetInputToNull();
if (rr != null)
{
recoPhonemes = StringFromWordArray(rr.Words, WordType.Pronunciation);
}
//txtRecoPho.Text = recoPhonemes;
return(recoPhonemes);
}
}
}
private void start()
{
Choices sList = new Choices();
sList.Add(new string[] { "hello", "find", "start", "monitoring", "login", "exit", "close", "quit", });
Grammar gr = new Grammar(new GrammarBuilder(sList));
try
{
sRecognize.RequestRecognizerUpdate();
sRecognize.LoadGrammar(gr);
sRecognize.SpeechRecognized += sRecognize_SpeechRecognized;
sRecognize.SetInputToDefaultAudioDevice();
sRecognize.RecognizeAsync(RecognizeMode.Multiple);
sRecognize.Recognize();
}
catch
{
return;
}
}
public static string getPassCode(string path)
{
ConvertMp3ToWav(path, path.Replace(".mp3", ".wav"));
SpeechRecognitionEngine sre = new SpeechRecognitionEngine();
Grammar gr = new DictationGrammar();
sre.LoadGrammar(gr);
sre.SetInputToWaveFile(path.Replace(".mp3", ".wav"));
sre.BabbleTimeout = new TimeSpan(Int32.MaxValue);
sre.InitialSilenceTimeout = new TimeSpan(Int32.MaxValue);
sre.EndSilenceTimeout = new TimeSpan(100000000);
sre.EndSilenceTimeoutAmbiguous = new TimeSpan(100000000);
StringBuilder sb = new StringBuilder();
while (true)
{
try
{
var recText = sre.Recognize();
if (recText == null)
{
break;
}
sb.Append(recText.Text);
}
catch (Exception ex)
{
//handle exception
//...
break;
}
}
return(sb.ToString());
}
private void SpeechToTextalgorithm()
{
// richTextBox1.Focus();
PromptBuilder pbuilder = new PromptBuilder();
SpeechRecognitionEngine sregEngine = new SpeechRecognitionEngine();
Choices slist = new Choices();
slist.Add(new string[] {
"go to email",
"go to subject",
"go to message"
//"Read email",
//"Read subject",
//"Read message",
//"sent"
// "next",
});
Grammar gr = new Grammar(new GrammarBuilder(slist));
try
{
sregEngine.RequestRecognizerUpdate();
sregEngine.LoadGrammar(gr);
sregEngine.SpeechRecognized += sregEngine_SpeechRecognized;
sregEngine.SetInputToDefaultAudioDevice();
sregEngine.RecognizeAsync(RecognizeMode.Multiple);
sregEngine.Recognize();
}
catch
{
return;
}
}
//First time recognition call
private void StartRecognition()
{
//Define preference synthesizer voice, female/male/neutral/..etc
synthesizer.SelectVoiceByHints(VoiceGender.Female, VoiceAge.Senior);
try
{
//recognizer should receive input from the default audio device
recognizer.SetInputToDefaultAudioDevice();
//Add event in case recognizer didn't recognize words in dictionary
recognizer.SpeechRecognitionRejected += recognizer_SpeechRecognitionRejected;
//Start recognition mode asyncronously, set mode to multiple because we don't want recognizer to stop
recognizer.RecognizeAsync(RecognizeMode.Multiple);
recognizer.Recognize();
}
catch
{
//In case of any error do nothing
return;
}
}
private void button3_Click(object sender, EventArgs e)
{
SpeechRecognitionEngine recognizer = new SpeechRecognitionEngine();
Grammar dictationGrammar = new DictationGrammar();
recognizer.LoadGrammar(dictationGrammar);
try
{
button3.Text = "Recognizing";
recognizer.SetInputToWaveFile("c:\\InMind\\temp\\fromClient3.wav");
RecognitionResult result = recognizer.Recognize();
button3.Text = result.Text;
}
catch (InvalidOperationException exception)
{
button3.Text = String.Format("Could not recognize input from default aduio device. Is a microphone or sound card available?\r\n{0} - {1}.", exception.Source, exception.Message);
}
finally
{
recognizer.UnloadAllGrammars();
}
}
public void Recognize()
{
SpeechRecognitionEngine recognizer = new SpeechRecognitionEngine(); // creates a new Recognizer for voice commands
Grammar dictationGrammar = new DictationGrammar();
recognizer.LoadGrammar(dictationGrammar); // loads default grammar
try
{
SetText("Listening...");
recognizer.SetInputToDefaultAudioDevice(); // sets the input device to the user's default input device
RecognitionResult result = recognizer.Recognize(); // used to capture the result
SetText(result.Text); // sets the result to the search box(textBox1)
if (Properties.Settings.Default.autoSearch)
{
ClickExecution(); // checks if the user wants automatic search after the word is captured
}
recognizer.UnloadAllGrammars();
}
catch (InvalidOperationException exception)
{
SetText(String.Format("Could not recognize input from default aduio device. Is a microphone or sound card available?\r\n{0} - {1}.", exception.Source, exception.Message)); // throws an error if something goes wrong
}
}
private void Run()
{
try
{
SpeechRecognitionEngine engine = new SpeechRecognitionEngine(new System.Globalization.CultureInfo(language));
//engine.SetInputToWaveFile(_fileName);
engine.SetInputToDefaultAudioDevice();
engine.LoadGrammar(new DictationGrammar());
engine.BabbleTimeout = TimeSpan.FromSeconds(3.0);
engine.EndSilenceTimeout = TimeSpan.FromSeconds(3.0);
engine.EndSilenceTimeoutAmbiguous = TimeSpan.FromSeconds(1.0);
engine.InitialSilenceTimeout = TimeSpan.FromSeconds(3.0);
_result = engine.Recognize();
}
//Once the recording is done, _operation empties recorded speech
finally
{
_operation.PostOperationCompleted(delegate {
RaiseCompleted();
}, null);
}
}
private void RdBtn_On_Click(object sender, RoutedEventArgs e)
{
while (RdBtn_On.IsChecked == true)
{
currentout = currentsit.lst_outputs.ElementAt(random.Next(0, currentsit.lst_outputs.Count));
TxtBl_Output.Text = currentout.OutputText;
speechSynthesizer.SpeakAsync(currentout.OutputText);
//Input für Grammatik einspeisen
Choices commands = new Choices();
foreach (Input x in currentout.lst_inputs)
{
commands.Add(x.InputText);
}
GrammarBuilder gBuilder = new GrammarBuilder();
gBuilder.Append(commands);
Grammar grammar = new Grammar(gBuilder);
recEngine.LoadGrammar(grammar);
recEngine.SpeechRecognized += RecEngine_SpeechRecognized;
recEngine.Recognize(TimeSpan.FromSeconds(5));
}
}
public void SCommands()
{
SpeechSynthesizer sSynth = new SpeechSynthesizer();
PromptBuilder pBuilder = new PromptBuilder();
SpeechRecognitionEngine sRecognize = new SpeechRecognitionEngine();
Choices sList = new Choices();
sList.Add(new string[] { "login", "signin", "register", "user", "password", "forgot" });
Grammar gr = new Grammar(new GrammarBuilder(sList));
try
{
sRecognize.RequestRecognizerUpdate();
sRecognize.LoadGrammar(gr);
sRecognize.SpeechRecognized += sRecognize_speech;
sRecognize.SetInputToDefaultAudioDevice();
sRecognize.RecognizeAsync(RecognizeMode.Multiple);
sRecognize.Recognize();
}catch (Exception ex)
{
}
}
private void button2_Click(object sender, EventArgs e)
{
button2.Text = "Listining.....";
SpeechRecognitionEngine sp = new SpeechRecognitionEngine();
Grammar gr = new DictationGrammar();
sp.LoadGrammar(gr);
try
{
sp.SetInputToDefaultAudioDevice();
RecognitionResult re = sp.Recognize();
textBox1.Text = re.Text;
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
finally
{
sp.UnloadAllGrammars();
}
button2.Text = "Text to speech";
}
static void RestartRec()
{
if (sre != null)
{
sre.Dispose();
}
//Preload DB entities once, store in private field and add them again here
Choices userReplies = new Choices();
userReplies.Add("hello");
sre = new SpeechRecognitionEngine();
GrammarBuilder gb = new GrammarBuilder();
gb.Append(userReplies);
Grammar g = new Grammar(gb);
sre.LoadGrammar(g);
sre.SpeechRecognized += new EventHandler <SpeechRecognizedEventArgs>(sre_SpeechRecognized);
sre.SetInputToDefaultAudioDevice();
// Start recognition.
sre.Recognize();
}
public void TestGetEngine()
{
// arrange
SpeechRecognitionEngine testEngine = lex4all.EngineControl.getEngine();
try
{
// act
testEngine.SetInputToAudioStream(lex4all.Properties.Resources.sampleAudio,
new SpeechAudioFormatInfo(32000, AudioBitsPerSample.Sixteen, AudioChannel.Mono));
RecognitionResult thisResult = testEngine.Recognize();
}
catch (Exception e)
{
// assert false case
Console.WriteLine(e.Message);
Assert.IsTrue(false);
}
// assert true case
Assert.IsTrue(true);
}
private void btnCatchText_Click(object sender, EventArgs e)
{
SpeechRecognitionEngine RecognitionEngine;
using (RecognitionEngine = new SpeechRecognitionEngine(new CultureInfo("en-US")))
{
RecognitionEngine.SetInputToWaveFile("D:/wav/test.wav");
//RecognitionEngine.RecognizeCompleted += new EventHandler<RecognizeCompletedEventArgs>(RecognitionEngine_RecognizeCompleted);
GrammarBuilder gb = new GrammarBuilder();
gb.AppendDictation();
Grammar g = new Grammar(gb);
g.Name = "Dictation Grammar";
//recognizer.LoadGrammar(g);
RecognitionEngine.LoadGrammar(g);
RecognitionResult Result = RecognitionEngine.Recognize();
RecognitionEngine.RecognizeAsync(RecognizeMode.Single);
StringBuilder Output = new StringBuilder();
foreach (RecognizedWordUnit Word in Result.Words)
{
Output.Append(Word.Text + " ");
}
// RecognitionEngine.RecognizeAsyncStop();
txtSpeak.Text = Output.ToString();
RecognitionEngine.Dispose();
//Dispose();
}
}
public int Recognize(string mp3_source)
{
string wav_destination = Directory + String.Format("\\default_input{0}.wav", TickTime.Now.Ticks);
if (mp3_source == wav_destination)
{
return(-1);
}
if (File.Exists(wav_destination))
{
File.Delete(wav_destination);
}
Asmodat.Audio.Converter.Mp3ToWAV(mp3_source, wav_destination);
SourceFile = wav_destination;
Engine.SetInputToWaveFile(SourceFile);
Engine.InitialSilenceTimeout = TimeSpan.FromSeconds(30);
RecognizedName = null;
Confidence = double.MinValue;
Engine.Recognize();
Engine.SetInputToNull();
if (File.Exists(wav_destination))
{
File.Delete(wav_destination);
}
return(RecognizedNumber);
}
//This function converst the passed memory stream and compares it to the passed Choices
//INPUT: stream with recording, Text choices to look for
//OUPUT: FunctionResult
//This does the speech recognition against the stream and coices
public functionResult convertToSpeechwithChoices(Stream ms, Choices c)
{
functionResult f = new functionResult();
SpeechRecognitionEngine recognizer = new SpeechRecognitionEngine(new System.Globalization.CultureInfo("en-US"));
//Create a dictionary Grammar and assign the coices to it
Grammar dictationGrammar = new DictationGrammar();
var gb = new GrammarBuilder(c);
var g = new Grammar(gb);
//Load the grammar for the speech recognition engine
recognizer.LoadGrammar(g);
try
{
//Go to the beginning of the stream
ms.Position = 0;
//Conver the stream into a wave stream
WaveStream pcmStream = new WaveFileReader(ms);
recognizer.SetInputToAudioStream(pcmStream, new SpeechAudioFormatInfo(16000, AudioBitsPerSample.Sixteen, AudioChannel.Mono));
//Do the speech recognition
RecognitionResult result = recognizer.Recognize();
f.Result = true;
f.recognitionResult = result;
}
catch (Exception ex)
{
f.Message = "ERROR: " + ex.Message;
f.Result = false;
}
finally
{
recognizer.UnloadAllGrammars();
}
return(f);
}
static void Main(string[] args)
{
SpeechRecognitionEngine sre = new SpeechRecognitionEngine();
Grammar gr = new DictationGrammar();
sre.LoadGrammar(gr);
sre.SetInputToWaveFile("C:sample.wav");
sre.BabbleTimeout = new TimeSpan(Int32.MaxValue);
sre.InitialSilenceTimeout = new TimeSpan(Int32.MaxValue);
sre.EndSilenceTimeout = new TimeSpan(100000000);
sre.EndSilenceTimeoutAmbiguous = new TimeSpan(100000000);
StringBuilder sb = new StringBuilder();
while (true)
{
try
{
var recText = sre.Recognize();
if (recText == null)
{
break;
}
sb.Append(recText.Text);
}
catch (Exception ex)
{
//handle exception
//...
break;
}
}
Console.WriteLine(sb.ToString());
Console.WriteLine("wciśnij dowolny klawisz");
Console.ReadKey();
}
void Record()
{
using (KinectAudioSource source = new KinectAudioSource
{
FeatureMode = true,
AutomaticGainControl = false,
SystemMode = SystemMode.OptibeamArrayOnly
})
{
RecognizerInfo recognizerInfo = SpeechRecognitionEngine.InstalledRecognizers().Where(r => r.Id == RecognizerId).FirstOrDefault();
if (recognizerInfo == null)
return;
SpeechRecognitionEngine speechRecognitionEngine = new SpeechRecognitionEngine(recognizerInfo.Id);
var gb = new GrammarBuilder {Culture = recognizerInfo.Culture};
gb.Append(choices);
var grammar = new Grammar(gb);
speechRecognitionEngine.LoadGrammar(grammar);
using (Stream sourceStream = source.Start())
{
speechRecognitionEngine.SetInputToAudioStream(sourceStream, new SpeechAudioFormatInfo(EncodingFormat.Pcm, 16000, 16, 1, 32000, 2, null));
isRunning = true;
while (isRunning)
{
RecognitionResult result = speechRecognitionEngine.Recognize();
if (result != null && OrderDetected != null && result.Confidence > 0.7)
OrderDetected(result.Text);
}
}
}
}
public string readAudio(string file)
{
SpeechRecognitionEngine sre = new SpeechRecognitionEngine();
Grammar gr = new DictationGrammar();
sre.LoadGrammar(gr);
sre.SetInputToWaveFile(file);
sre.BabbleTimeout = new TimeSpan(Int32.MaxValue);
sre.InitialSilenceTimeout = new TimeSpan(Int32.MaxValue);
sre.EndSilenceTimeout = new TimeSpan(100000000);
sre.EndSilenceTimeoutAmbiguous = new TimeSpan(100000000);
StringBuilder sb = new StringBuilder();
while (true)
{
try
{
var recText = sre.Recognize();
if (recText == null)
{
break;
}
sb.Append(recText.Text);
}
catch (Exception ex)
{
//handle exception
//...
break;
}
}
return(sb.ToString());
}
static void Main(string[] args)
{
port = new SerialPort("COM3", 9600);
SpeechRecognitionEngine sre = new SpeechRecognitionEngine(new System.Globalization.CultureInfo("pt-br"));
Choices frases = new Choices();
frases.Add(new string[] { "liga", "desliga", "sair" });
GrammarBuilder builder = new GrammarBuilder();
builder.Append(frases);
Grammar g = new Grammar(builder);
sre.SpeechRecognized += new EventHandler <SpeechRecognizedEventArgs>(sre_SpeechRecognized);
sre.SetInputToDefaultAudioDevice();
sre.LoadGrammar(g);
do
{
sre.Recognize();
} while (!sair);
}
private void button10_Click_1(object sender, EventArgs e)
{
SpeechRecognitionEngine recognizer = new SpeechRecognitionEngine();
Choices colors = new Choices();
colors.Add(new string[] { "red", "green", "blue", "who", "mehak" });
GrammarBuilder gb = new GrammarBuilder();
gb.Append(colors);
// Create the Grammar instance and load it into the speech recognition engine.
Grammar g = new Grammar(gb);
recognizer.LoadGrammar(g);
try
{
recognizer.SetInputToDefaultAudioDevice();
RecognitionResult result = recognizer.Recognize();
if (result == null)
{
label7.Text = "";
}
else
{
label7.Text = result.Text;
if (label7.Text == "red")
{
button3.PerformClick();
}
}
}
catch (InvalidOperationException exception)
{
button1.Text = String.Format("Could not recognize input from default aduio device. Is a microphone or sound card available?\r\n{0} - {1}.", exception.Source, exception.Message);
}
finally
{
recognizer.UnloadAllGrammars();
}
}
static void CommandThreadFunc()
{
while (cameraThread != null && !cameraFixed)
{
Thread.Sleep(3000);
}
if (cameraThread != null)
{
cameraThread.Join();
}
using (var source = new KinectAudioSource())
{
source.FeatureMode = true;
source.AutomaticGainControl = false; //Important to turn this off for speech recognition
source.SystemMode = SystemMode.OptibeamArrayOnly; //No AEC for this sample
RecognizerInfo ri = SpeechRecognitionEngine.InstalledRecognizers().Where(r => r.Id == RecognizerId).FirstOrDefault();
if (ri == null)
{
Console.WriteLine("Could not find speech recognizer: {0}. Please refer to the sample requirements.", RecognizerId);
return;
}
Console.WriteLine("Using: {0}", ri.Name);
using (var sre = new SpeechRecognitionEngine(ri.Id))
{
var i4c3dCommand = new Choices();
i4c3dCommand.Add(COMMAND_INITIALIZE);
i4c3dCommand.Add(COMMAND_ZOOM_IN);
i4c3dCommand.Add(COMMAND_ZOOM_OUT);
i4c3dCommand.Add(COMMAND_STOP);
i4c3dCommand.Add(COMMAND_LEFT);
i4c3dCommand.Add(COMMAND_RIGHT);
i4c3dCommand.Add(COMMAND_UP);
i4c3dCommand.Add(COMMAND_DOWN);
//i4c3dCommand.Add(COMMAND_ALIAS);
//i4c3dCommand.Add(COMMAND_MAYA);
//i4c3dCommand.Add(COMMAND_RTT);
//i4c3dCommand.Add(COMMAND_SHOWCASE);
var gb = new GrammarBuilder();
//Specify the culture to match the recognizer in case we are running in a different culture.
gb.Culture = ri.Culture;
gb.Append(i4c3dCommand);
// Create the actual Grammar instance, and then load it into the speech recognizer.
var g = new Grammar(gb);
sre.LoadGrammar(g);
sre.SpeechRecognized += SreSpeechRecognizedI4C3D;
sre.SpeechHypothesized += SreSpeechHypothesized;
sre.SpeechRecognitionRejected += SreSpeechRecognitionRejected;
using (Stream s = source.Start())
{
sre.SetInputToAudioStream(s,
new SpeechAudioFormatInfo(
EncodingFormat.Pcm, 16000, 16, 1,
32000, 2, null));
Console.WriteLine("Recognizing. Say: 'Start' to start camera move");
while (!i4c3dStarted) Thread.Sleep(1); // �ҋ@
while (!exit)
{
sre.Recognize(new TimeSpan(100000)); // 1sec
//sre.Recognize();
}
Console.WriteLine("Stopping recognizer ...");
}
}
}
}
/**************************************************************************************/
/*
/* Testing algorithms
/*
/***************************************************************************************/
/// <summary>
/// Runs the testing algorithm
/// </summary>
public void testingAlgorithmDiscriminative()
{
for (int NTrainingSpeakers = 1; NTrainingSpeakers < MSpeakers; NTrainingSpeakers++)
{
for (int NTrainingSamplesPerSpeaker = startingNumberOfSamples; NTrainingSamplesPerSpeaker <= MSample; NTrainingSamplesPerSpeaker++)
{
setUpTrainingSet(NTrainingSpeakers, NTrainingSamplesPerSpeaker);
foreach (List<int> speakerList in trainingSet[0])
{
foreach (List<int> sampleList in trainingSet[1])
{
Dictionary<string, List<string>> pronunciations;
/*if (input == null)
{
pronunciations = trainAllWords(speakerList, sampleList);
}
else
{
List<int> trueSampleList = new List<int>();
foreach (int sample in sampleList)
{
trueSampleList.Add(sample + 1);
}
pronunciations = input.output(speakerList, trueSampleList);
System.Diagnostics.Debug.WriteLine(pronunciations.Count);
}*/
// set up testSpeakerSet
List<int> testSpeakerSet = new List<int>();
for (int speakerNum = 0; speakerNum < MSpeakers; speakerNum++)
{
if (!speakerList.Contains(speakerNum))
{
testSpeakerSet.Add(speakerNum);
}
}
// begin testing
foreach (int vocabSize in V)
{
foreach (int iTestSpeaker in testSpeakerSet)
{
if (input == null)
{
pronunciations = trainAllWords(speakerList, sampleList);
}
else
{
List<int> trueSampleList = new List<int>();
foreach (int sample in sampleList)
{
trueSampleList.Add(sample + 1);
}
pronunciations = input.outputDiscriminative(speakerList, trueSampleList, (iTestSpeaker+ 1));
System.Diagnostics.Debug.WriteLine(pronunciations.Count);
}
for (int iWordType = 1; iWordType <= MWordTypes; iWordType++)
{
System.Diagnostics.Debug.WriteLine("Testing: word" + iWordType);
for (int iRepeat = 1; iRepeat <= repeats; iRepeat++)
{
// create random vocab
GrammarCreator gc = new GrammarCreator(grammarDirectory, "repeat_" + grammarCounter, "allcombinations");
grammarCounter++;
gc.boundgr(true);
gc.boundrule(true, gc.grammarRuleName);
// add correct word
for (int i = 0; i < pronunciations[data.listOfWords[iWordType]].Count; i++)
{
for (int j = 0; j < MSample; j++)
{
ConfusionMatrix[NTrainingSpeakers - 1, iTestSpeaker, MSample * (iWordType - 1) + j, numberOfAlternates * (iWordType - 1) + i].den++;
}
gc.LogGrammar("<item><token sapi:pron=\"" + pronunciations[data.listOfWords[iWordType]][i] + "\">" + data.listOfWords[iWordType] + "_" + i + "</token></item>");
}
/*foreach (string pronun in pronunciations[data.listOfWords[iWordType]])
{
gc.LogGrammar("<item><token sapi:pron=\"" + pronun + "\">" + data.listOfWords[iWordType] + "</token></item>");
}*/
// add V - 1 random words
Random random = new Random();
List<int> wordTypesChosen = new List<int>();
wordTypesChosen.Add(iWordType);
//ConfusionMatrix[NTrainingSpeakers - 1, iTestSpeaker, iWordType - 1, iWordType - 1].den += MSample;
int wordCount = 1;
while (wordCount < vocabSize)
{
int randomWordType;
if (vocabSize < MWordTypes)
{
do
{
randomWordType = random.Next(1, MWordTypes + 1); // 1 to MWordTypes
} while (wordTypesChosen.Contains(randomWordType));
// add word
wordTypesChosen.Add(randomWordType);
for (int i = 0; i < pronunciations[data.listOfWords[randomWordType]].Count; i++)
{
for (int j = 0; j < MSample; j++)
{
ConfusionMatrix[NTrainingSpeakers - 1, iTestSpeaker, MSample * (iWordType - 1) + j, numberOfAlternates * (randomWordType - 1) + i].den++;
}
gc.LogGrammar("<item><token sapi:pron=\"" + pronunciations[data.listOfWords[randomWordType]][i] + "\">" + data.listOfWords[randomWordType] + "_" + i + "</token></item>");
}
wordCount++;
}
else
{
for (int k = 1; k <= MWordTypes; k++)
{
randomWordType = k;
// we don't add the "correct" word
if (randomWordType != iWordType)
{
wordTypesChosen.Add(randomWordType);
for (int i = 0; i < pronunciations[data.listOfWords[randomWordType]].Count; i++)
{
for (int j = 0; j < MSample; j++)
{
ConfusionMatrix[NTrainingSpeakers - 1, iTestSpeaker, MSample * (iWordType - 1) + j, numberOfAlternates * (randomWordType - 1) + i].den++;
}
gc.LogGrammar("<item><token sapi:pron=\"" + pronunciations[data.listOfWords[randomWordType]][i] + "\">" + data.listOfWords[randomWordType] + "_" + i + "</token></item>");
}
//System.Diagnostics.Debug.WriteLine("word chosen: " + randomWordType);
}
}
break;
}
//ConfusionMatrix[NTrainingSpeakers - 1, iTestSpeaker, iWordType - 1, randomWordType - 1].den+=MSample;
/*foreach (string pronun in pronunciations[data.listOfWords[randomWordType]])
{
gc.LogGrammar("<item><token sapi:pron=\"" + pronun + "\">" + data.listOfWords[randomWordType] + "</token></item>");
}*/
//wordCount++;
}
gc.boundrule(false, "");
gc.boundgr(false);
// setup recognizer
SpeechRecognitionEngine rec = new SpeechRecognitionEngine();
rec.LoadGrammar(gc.getGrammar());
// recognizing
for (int iSample = 1; iSample <= MSample; iSample++)
{
rec.SetInputToWaveFile(data.getAudioName(iTestSpeaker, iWordType, iSample));
RecognitionResult result;
try
{
result = rec.Recognize();
}
catch (Exception e)
{
System.Diagnostics.Debug.WriteLine(e.Message);
System.Diagnostics.Debug.WriteLine(data.getAudioName(iTestSpeaker, iWordType, iSample));
continue;
}
//System.Diagnostics.Debug.WriteLine("recognising");
if (result == null)
{
ConfusionMatrix[NTrainingSpeakers - 1, iTestSpeaker, MSample * (iWordType - 1) + iSample - 1, numberOfAlternates * MWordTypes].num++;
}
else
{
string[] word = result.Alternates[0].Words[0].Text.Split('_');
word = wordTypeResult(2, result);
//if (result.Alternates.Count > 2)
// System.Diagnostics.Debug.WriteLine("No. of results found for wordType " + iWordType + "sample " + iSample + " = " + result.Alternates[2].Confidence);
ConfusionMatrix[NTrainingSpeakers - 1, iTestSpeaker, MSample * (iWordType - 1) + iSample - 1, numberOfAlternates * (Array.IndexOf(data.listOfWords.ToArray(), word[0]) - 1) + int.Parse(word[1])].num++;
if (word[0].Equals(data.listOfWords[iWordType]))
SampleAccuracy[NTrainingSpeakers - 1, NTrainingSamplesPerSpeaker - 1, Array.IndexOf(V, vocabSize), iTestSpeaker, iWordType - 1, iSample - 1].num++;
}
/*
if (result != null && result.Alternates[0].Words[0].Text.Split('_')[0].Equals(data.listOfWords[iWordType]))
{
SampleAccuracy[NTrainingSpeakers - 1, NTrainingSamplesPerSpeaker - 1, Array.IndexOf(V, vocabSize), iTestSpeaker, iWordType - 1, iSample - 1].num++;
//System.Diagnostics.Debug.WriteLine(NTrainingSpeakers + "_" + NTrainingSamplesPerSpeaker + "_" + Array.IndexOf(V, vocabSize) + "_" + iTestSpeaker + "_" + iWordType + "_" + iSample);
}*/
SampleAccuracy[NTrainingSpeakers - 1, NTrainingSamplesPerSpeaker - 1, Array.IndexOf(V, vocabSize), iTestSpeaker, iWordType - 1, iSample - 1].den++;
}
gc.Destroy();
}
}
}
}
// end testing
}
}
}
}
}
private void BuildGrammarforRecognizer(object recognizerInfo)
{
EnableKinectAudioSource();
var grammarBuilder = new GrammarBuilder { Culture = (recognizerInfo as RecognizerInfo).Culture };
// Creating another Grammar and load
var newGrammarBuilder = new GrammarBuilder();
newGrammarBuilder.Append(new Choices("Schließe die Anwendung", "Ich hasse euch alle", "nächsten Folie"));
var grammarClose = new Grammar(newGrammarBuilder);
int SamplesPerSecond = 16000;
int bitsPerSample = 16;
int channels = 1;
int averageBytesPerSecond = 32000;
int blockAlign = 2;
using (var speechRecognizer = new SpeechRecognitionEngine((recognizerInfo as RecognizerInfo).Id))
{
speechRecognizer.LoadGrammar(grammarClose);
speechRecognizer.SpeechRecognized += SreSpeechRecognized;
speechRecognizer.SpeechHypothesized += SreSpeechHypothesized;
speechRecognizer.SpeechRecognitionRejected += SreSpeechRecognitionRejected;
using (Stream s = source.Start())
{
speechRecognizer.SetInputToAudioStream(
s, new SpeechAudioFormatInfo(EncodingFormat.Pcm, SamplesPerSecond, bitsPerSample, channels, averageBytesPerSecond, blockAlign, null));
while (keepRunning)
{
RecognitionResult result = speechRecognizer.Recognize(new TimeSpan(0, 0, 5));
}
speechRecognizer.RecognizeAsyncStop();
}
}
}
public void Listen()
{
source.EchoCancellationMode = EchoCancellationMode.None; // No AEC for this sample
source.AutomaticGainControlEnabled = false; // Important to turn this off for speech recognition
RecognizerInfo ri = GetKinectRecognizer();
var sre = new SpeechRecognitionEngine(ri.Id);
sre.SpeechRecognized += SreSpeechRecognized;
sre.SpeechHypothesized += SreSpeechHypothesized;
sre.SpeechRecognitionRejected += SreSpeechRecognitionRejected;
System.IO.Stream s = source.Start();
sre.SetInputToAudioStream(s, new SpeechAudioFormatInfo(EncodingFormat.Pcm, 16000, 16, 1, 32000, 2, null));
while (!done)
{
Grammar newGrammar = cell.GetNewGrammar();
if (newGrammar != null)
sre.LoadGrammar(newGrammar);
sre.Recognize(new TimeSpan(0, 0, 0, 0, 500));
}
}
private void button1_Click(object sender, EventArgs e)
{
SpeechRecognitionEngine recognitionEngine = new SpeechRecognitionEngine();
recognitionEngine.SetInputToDefaultAudioDevice();
recognitionEngine.LoadGrammar(new DictationGrammar());
RecognitionResult result = recognitionEngine.Recognize(new TimeSpan(0, 0, 20));
foreach (RecognizedWordUnit word in result.Words)
{
MessageBox.Show(word.Text);
}
}
private void button1_Click(object sender, EventArgs e)
{
SpeechSynthesizer sSynth = new SpeechSynthesizer();
PromptBuilder pBuilder = new PromptBuilder();
SpeechRecognitionEngine sRecognize = new SpeechRecognitionEngine();
Choices NumbersCh = new Choices();
for (int i = -999; i < 1000; i++)
{
NumbersCh.Add(i.ToString());
}
NumbersCh.Add("Times");
NumbersCh.Add("Multiply");
NumbersCh.Add("Divided");
NumbersCh.Add("Divide");
NumbersCh.Add("Plus");
NumbersCh.Add("Minus");
NumbersCh.Add("Add");
NumbersCh.Add("Subtract");
NumbersCh.Add("Power");
NumbersCh.Add("Left Over");
Choices OperatorCh = new Choices();
Grammar MathGr = new Grammar(new GrammarBuilder(NumbersCh));
Choices MainCh = new Choices();
MainCh.Add(new string[] { "Jack Hello" });
MainCh.Add(new string[] { "Jack Launch Chrome" });
MainCh.Add(new string[] { "Jack Go To My Facebook" });
MainCh.Add(new string[] { "Jack Launch Go" });
MainCh.Add(new string[] { "Jack Launch Rim World" });
MainCh.Add(new string[] { "Jack Launch Rust" });
MainCh.Add(new string[] { "Jack Launch Sins" });
MainCh.Add(new string[] { "Jack Launch K S P" });
MainCh.Add(new string[] { "Jack Launch Skype" });
MainCh.Add(new string[] { "Jack Launch Unity" });
MainCh.Add(new string[] { "Jack Wake Up" });
MainCh.Add(new string[] { "That will be all for now" });
MainCh.Add(new string[] { "Jack Close Window" });
MainCh.Add(new string[] { "Jack Save Progress" });
MainCh.Add(new string[] { "Alt Tab" });
MainCh.Add(new string[] { "Jack Tell A Joke" });
MainCh.Add(new string[] { "That Was A Good One Jack" });
MainCh.Add(new string[] { "Jack You Are Funny" });
MainCh.Add(new string[] { "Enter My Number" });
MainCh.Add(new string[] { "What Are My Numbers?" });
MainCh.Add(new string[] { "What Is My Answer?" });
MainCh.Add(new string[] { "Jack Lock" });
MainCh.Add(new string[] { "Jack Exit" });
Grammar MainGr = new Grammar(new GrammarBuilder(MainCh));
try
{
sRecognize.RequestRecognizerUpdate();
sRecognize.LoadGrammar(MainGr);
sRecognize.LoadGrammar(MathGr);
sRecognize.SpeechRecognized += sRecognize_SpeechRecognized;
sRecognize.SetInputToDefaultAudioDevice();
sRecognize.RecognizeAsync(RecognizeMode.Multiple);
sRecognize.Recognize();
}
catch
{
return;
}
}
static void CameraThreadFunc()
{
using (var source = new KinectAudioSource())
{
//nui.NuiCamera.ElevationAngle = angle;
source.FeatureMode = true;
source.AutomaticGainControl = false; //Important to turn this off for speech recognition
source.SystemMode = SystemMode.OptibeamArrayOnly; //No AEC for this sample
RecognizerInfo ri = SpeechRecognitionEngine.InstalledRecognizers().Where(r => r.Id == RecognizerId).FirstOrDefault();
if (ri == null)
{
Console.WriteLine("Could not find speech recognizer: {0}. Please refer to the sample requirements.", RecognizerId);
return;
}
Console.WriteLine("Using: {0}", ri.Name);
using (var sre = new SpeechRecognitionEngine(ri.Id))
{
var cameraCommand = new Choices();
cameraCommand.Add(COMMAND_START);
cameraCommand.Add(COMMAND_FIX);
cameraCommand.Add(COMMAND_DEFAULT);
cameraCommand.Add(COMMAND_UP);
cameraCommand.Add(COMMAND_DOWN);
var gb = new GrammarBuilder();
//Specify the culture to match the recognizer in case we are running in a different culture.
gb.Culture = ri.Culture;
gb.Append(cameraCommand);
// Create the actual Grammar instance, and then load it into the speech recognizer.
var g = new Grammar(gb);
sre.LoadGrammar(g);
sre.SpeechRecognized += SreSpeechRecognizedCamara;
sre.SpeechHypothesized += SreSpeechHypothesized;
sre.SpeechRecognitionRejected += SreSpeechRecognitionRejected;
using (Stream s = source.Start())
{
sre.SetInputToAudioStream(s,
new SpeechAudioFormatInfo(
EncodingFormat.Pcm, 16000, 16, 1,
32000, 2, null));
Console.WriteLine("Recognizing. Say: 'Start' to start camera move");
while (!cameraFixed)
{
sre.Recognize(new TimeSpan(1000000)); // 1sec
//sre.Recognize();
}
//sre.RecognizeAsync(RecognizeMode.Multiple);
Console.WriteLine("Stopping recognizer ...");
//sre.RecognizeAsyncStop();
}
}
}
}
private string Recognize()
{
using (SpeechRecognitionEngine sre = new SpeechRecognitionEngine(new CultureInfo("zh-CN")))
{
Choices colors = new Choices(new string[] { "宝塔镇河妖" });
GrammarBuilder gb = new GrammarBuilder();
gb.Append(colors);
// Create the Grammar instance.
Grammar g = new Grammar(gb);
sre.LoadGrammar(g);
// Configure the input to the recognizer.
sre.SetInputToWaveFile("d:\\output.mp3");
RecognitionResult result = sre.Recognize();
return result == null ? string.Empty : result.Text;
}
}
private void button1_Click(object sender, EventArgs e)
{
SpeechRecognitionEngine SRE = new SpeechRecognitionEngine();
//SRE.SetInputToDefaultAudioDevice();
GrammarBuilder GB = new GrammarBuilder();
GB.Append(new Choices(new string[] { "銅葉綠素", "華夏技術學院","服貿","馬來西亞航空","王鴻遠","北捷殺人","阿帕契","課綱"}));
Grammar G = new Grammar(GB);
G.Name = "main command grammar";
SRE.LoadGrammar(G);
DictationGrammar DG = new DictationGrammar(); //自然發音
DG.Name = "dictation";
SRE.LoadGrammar(DG);
try
{
label4.Text = "Speak Now";
SRE.SetInputToDefaultAudioDevice();
//SRE.RecognizeAsync(RecognizeMode.Multiple);
RecognitionResult result = SRE.Recognize();
if (result == null) return;
label8.Text = result.Text;
txtKeyword1.Text = result.Text;
}
catch (InvalidOperationException exception)
{
//button1.Text = String.Format("Could not recognize input from default aduio device. Is a microphone or sound card available?\r\n{0} - {1}.", exception.Source, exception.Message);
}
finally
{
SRE.UnloadAllGrammars();
}
}
public void RecognizeSpeech()
{
SpeechRecognitionEngine recognizer = new SpeechRecognitionEngine();
recognizer.LoadGrammarCompleted += new EventHandler<LoadGrammarCompletedEventArgs>(LoadGrammarCompleted);
recognizer.SpeechRecognized += new EventHandler<SpeechRecognizedEventArgs>(SpeechRecognized);
recognizer.SpeechRecognitionRejected += new EventHandler<SpeechRecognitionRejectedEventArgs>(SpeechRejected);
recognizer.SetInputToDefaultAudioDevice();
GrammarBuilder commandStarter = new GrammarBuilder("Command");
GrammarBuilder clear = new GrammarBuilder("Clear");
GrammarBuilder insert = new GrammarBuilder("Insert");
Choices gates = new Choices(new string[] { "and", "or", "not", "exor", "nor", "nand" });
Choices columns = new Choices(new string[] { "zero","one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen" });
Choices rows = new Choices(new string[] { "zero" ,"one", "two", "three", "four", "five", "six", "seven", "eight", "nine" });
//Choices orientation = new Choices(new string[] { "left", "right", "up", "down" });
insert.Append(gates);
insert.Append("R");
insert.Append(rows);
insert.Append("C");
insert.Append(columns);
//insert.Append("towards");
//insert.Append(orientation);
GrammarBuilder connect = new GrammarBuilder("Connect");
connect.Append("output");
connect.Append(columns);
connect.Append(rows);
connect.Append("to");
connect.Append("input");
connect.Append(columns);
connect.Append(rows);
Grammar _clear_grammar = new Grammar(clear);
Grammar _insert_grammar = new Grammar(insert);
Grammar _connect_grammar = new Grammar(connect);
Grammar _command_starter = new Grammar(commandStarter);
recognizer.LoadGrammarAsync(_clear_grammar);
recognizer.LoadGrammarAsync(_insert_grammar);
recognizer.LoadGrammarAsync(_connect_grammar);
recognizer.LoadGrammarAsync(_command_starter);
while (true)
{
recognizer.Recognize();
//recognizer.RecognizeAsync(RecognizeMode.Multiple);
}
}