void Start() { dicRecognizer = new DictationRecognizer(); dicRecognizer.InitialSilenceTimeoutSeconds = 10; // 確定 dicRecognizer.DictationResult += (text, confidence) => { gameObject.GetComponent <UnityEngine.UI.Text>().text = text; GUIUtility.systemCopyBuffer = text; // System.Diagnostics.Process.Start(path); }; // 推測 dicRecognizer.DictationHypothesis += (text) => { // 推測時にする処理 }; // 停止時 dicRecognizer.DictationComplete += (completeCause) => { // 要因がタイムアウトなら再び起動 if (completeCause == DictationCompletionCause.TimeoutExceeded) { dicRecognizer.Start(); } }; dicRecognizer.Start(); }
/// <summary> /// Called when the game is started. <para/> /// We setup the voice recog /// /// preconditions: Language Engine exists. /// /// postconditions: dictationRecognizer is setup. /// </summary> private void Start() { Debug.Log(string.Format("SpeechToText::Start")); // create the DictationRecognizer, it will start recog text from the mic. dictationRecognizer = new DictationRecognizer(); // When speech has been recognized. dictationRecognizer.DictationResult += OnDictationResult; // make sure to rerun the dictation if it finishes dictationRecognizer.DictationComplete += (DictationCompletionCause cause) => { Debug.Log("DictationCompletionCause: " + cause); if (/*cause != DictationCompletionCause.Canceled && */ cause != DictationCompletionCause.Complete) { dictationRecognizer.Start(); } }; // catch errors and debug them. dictationRecognizer.DictationError += (string error, int hresult) => { Debug.LogError("DictationError: " + error); }; // start it now. dictationRecognizer.Start(); }
// Use this for initialization void Start() { /*_gestureRecognizer = new GestureRecognizer(); * _gestureRecognizer.TappedEvent += _gestureRecognizer_TappedEvent; * _gestureRecognizer.StartCapturingGestures(); */ _dictationRecognizer.Start(); }
public void StartSpeech() { dictationRecogniser.Start(); Statistics = new SpeechStatistics { StartTime = Time.time }; Status = SpeechStatus.Speeking; lastWordSaid = Time.time; }
void Start() { m_DictationRecognizer = new DictationRecognizer(); m_DictationRecognizer.InitialSilenceTimeoutSeconds = 600; m_DictationRecognizer.AutoSilenceTimeoutSeconds = 600; //m_Hypotheses = new Text(); //m_Recognitions = new Text(); resultText = ""; hypothesisText = ""; m_DictationRecognizer.DictationResult += (text, confidence) => { //Debug.LogFormat("Dictation result: {0}", text); // m_Recognitions.text += text + "\n"; //print("found a result"); lock (myLock) { resultText += text + " "; } }; m_DictationRecognizer.DictationHypothesis += (text) => { //Debug.LogFormat("Dictation hypothesis: {0}", text); // m_Hypotheses.text += text; print("here"); lock (myLock) { hypothesisText = text; } }; m_DictationRecognizer.DictationComplete += (completionCause) => { //print("in complete"); /** * if (completionCause != DictationCompletionCause.Complete) * print(completionCause); */ //Debug.LogErrorFormat("Dictation completed unsuccessfully: {0}.", completionCause); m_DictationRecognizer.Start(); }; m_DictationRecognizer.DictationError += (error, hresult) => { Debug.LogErrorFormat("Dictation error: {0}; HResult = {1}.", error, hresult); }; m_DictationRecognizer.Start(); StartCoroutine("CutClips"); }
/// <summary> /// Turns on the dictation recognizer and begins recording audio from the default microphone. /// </summary> /// <returns>The audio clip recorded from the microphone.</returns> public AudioClip StartRecording() { PhraseRecognitionSystem.Shutdown(); dictationRecognizer.Start(); dictationDisplay.text = "Dictation is starting. It may take time to display your text the first time, but begin speaking now..."; hasRecordingStarted = true; return(Microphone.Start(deviceName, true, messageLength, samplingRate)); }
private void DictationRecognizer_DictationError(string error, int hresult) { Debug.Log("Error: " + error); var dictationHandlers = (from i in FindObjectsOfType(typeof(MonoBehaviour)) where i is IMyDictationHandler select((IMyDictationHandler)i)).ToArray(); foreach (var i in dictationHandlers) { i.OnDictationError(error, hresult); } dictationRecognizer.Start(); }
void onDictationComplete(DictationCompletionCause cause) { if (cause != DictationCompletionCause.Complete) { Debug.LogErrorFormat("Dictation completed unsuccessfully: {0}.", cause); } if (cause == DictationCompletionCause.TimeoutExceeded) { dictationRecognizer.Stop(); dictationRecognizer.Start(); } }
void Start() { Debug.Log("start"); LoadSupportedLanguages(); //SetTargetLang("chinese simplified"); //StartCoroutine(TranslateText("Waiting for speech")); dictationRecognizer = new DictationRecognizer(); dictationRecognizer.DictationHypothesis += (text) => { Debug.LogFormat("Dictation hypothesis: {0}", text); WriteOut(text); }; dictationRecognizer.DictationResult += (text, confidence) => { Debug.LogFormat("Dictation result: {0}", text); var bits = text.Split(' '); if (bits[0] == "translate" && (bits.Length == 3 || bits.Length == 4)) { string name = bits[2]; if (text.EndsWith("simplified chinese") || text.EndsWith("chinese simplified")) { name = "chinese simplified"; } else if (text.EndsWith("traditional chinese") || text.EndsWith("chinese traditional")) { name = "chinese traditional"; } SetTargetLang(name); return; } englishS = "english: " + text + ". "; WriteOut(); StartCoroutine(TranslateText(text)); }; dictationRecognizer.DictationComplete += (completionCause) => { Debug.LogErrorFormat("Dictation completed: {0}.", completionCause); dictationRecognizer.Start(); }; dictationRecognizer.DictationError += (error, hresult) => { Debug.LogErrorFormat("Dictation error: {0}; HResult = {1}.", error, hresult); }; dictationRecognizer.Start(); }
public void StartDetection() { Debug.Log("Starte Dictation Mode"); //Debug.Log(dictationRecognizer.ToString()); dictationRecognizer.Start(); //Debug.Log("Dictation started"); }
//public ChatBot bot; //SpeechToTextResult m_LastResult; void Start() { m_DictationRecognizer = new DictationRecognizer(ConfidenceLevel.High, DictationTopicConstraint.Dictation); m_DictationRecognizer.DictationResult += (text, confidence) => { Debug.LogFormat("Dictation result: {0}", text); m_Recognitions.text += text + "\n"; //bot.SendChat(text); }; m_DictationRecognizer.DictationHypothesis += (text) => { Debug.LogFormat("Dictation hypothesis: {0}", text); m_Hypotheses.text += text + "\n"; }; m_DictationRecognizer.DictationComplete += (completionCause) => { if (completionCause != DictationCompletionCause.Complete) { Debug.LogErrorFormat("Dictation completed unsuccessfully: {0}.", completionCause); } }; m_DictationRecognizer.DictationError += (error, hresult) => { Debug.LogErrorFormat("Dictation error: {0}; HResult = {1}.", error, hresult); }; // m_LastResult = new SpeechToTextResult("", false); m_DictationRecognizer.Start(); }
private void Start() { m_DictationRecognizer = new DictationRecognizer(); m_DictationRecognizer.DictationResult += (text, confidence) => { OnSpeechResult?.Invoke(this, text); }; m_DictationRecognizer.DictationHypothesis += (text) => { OnSpeechHypothesis?.Invoke(this, text); }; m_DictationRecognizer.DictationComplete += (completionCause) => { if (completionCause != DictationCompletionCause.Complete) { Debug.LogErrorFormat("Dictation completed unsuccessfully: {0}.", completionCause); } }; m_DictationRecognizer.DictationError += (error, hresult) => { Debug.LogErrorFormat("Dictation error: {0}; HResult = {1}.", error, hresult); }; m_DictationRecognizer.Start(); }
void Start() { if (!m_enableListening) { return; } m_DictationRecognizer = new DictationRecognizer(); m_DictationRecognizer.DictationResult += VoiceResult; m_DictationRecognizer.DictationHypothesis += VoiceHypothesis; m_DictationRecognizer.DictationComplete += (completionCause) => { if (completionCause != DictationCompletionCause.Complete) { Debug.LogErrorFormat("Dictation completed unsuccessfully: {0}.", completionCause); } }; m_DictationRecognizer.DictationError += (error, hresult) => { Debug.LogErrorFormat("Dictation error: {0}; HResult = {1}.", error, hresult); }; m_DictationRecognizer.Start(); }
private void Start() { Advertise("VoicePub", "/hololens/audio/user_transcript", 1, out pub); voicebox = gameObject.GetComponent <TextToSpeech>(); // Activation phrase for dictation Keywords.Add("Hello", () => { ros.std_msgs.String msg = new ros.std_msgs.String("Hello!"); if (pub != null) { pub.SendMessage(msg); } voicebox.StartSpeaking("Hello"); }); Keywords.Add("record this", () => { PhraseRecognitionSystem.Shutdown(); StartBeep.Play(); dictationRecognizer.Start(); }); dictationRecognizer = new DictationRecognizer(); dictationRecognizer.DictationComplete += DictationComplete; dictationRecognizer.DictationError += DictationError; dictationRecognizer.DictationHypothesis += DictationHypothesis; dictationRecognizer.DictationResult += DictationResult; keywordRecognizer = new KeywordRecognizer(Keywords.Keys.ToArray()); keywordRecognizer.OnPhraseRecognized += KeywordRecognizer_OnPhraseRecognized; keywordRecognizer.Start(); }
/// <summary> /// Open for input /// </summary> public void TurnOn() { if (recognizer.Status == SpeechSystemStatus.Stopped) { recognizer.Start(); } }
void Start() { //set voice controls to false voiceContolsOn = false; //disable all panel items to be shown when name is interpreted playerName.enabled = false; progressText.enabled = false; loadingimage.enabled = false; loadingimageprogress.enabled = false; //initialise name to empty string - reset previous rounds name if present PlayerPrefs.SetString("Name", ""); // Get scripts to access methods. startgame = gameObject.GetComponent <StartGame>(); pause = GameObject.Find("Main Camera").GetComponent <Pause>(); options = GameObject.Find("VikingSoundHorn").GetComponent <Options>(); // All all voice commands to Dictionary AddAllVoiceCommands(); //set up dictation recogniser to allow user to input name dictationRecognizer = new DictationRecognizer(); //set timeout period for dictation recognizer dictationRecognizer.InitialSilenceTimeoutSeconds = 15; dictationRecognizer.DictationResult += DictationRecognizer_DictationResult; dictationRecognizer.DictationHypothesis += DictationRecognizer_DictationHypothesis; dictationRecognizer.Start(); //added timeout to dictation for name - after 15 seconds disable and enable voice commands Invoke("DicationTimeout", 15); }
public void StartDictation() { if (PhraseRecognitionSystem.Status != SpeechSystemStatus.Stopped) { PhraseRecognitionSystem.Shutdown(); } m_DictationRecognizer = new DictationRecognizer(); m_DictationRecognizer.DictationResult += (string text, ConfidenceLevel confidence) => { m_Recognitions.text += text + "\n"; }; m_DictationRecognizer.DictationHypothesis += ((string text) => { m_Hypotheses.text += text + "\n"; }); m_DictationRecognizer.DictationComplete += ((DictationCompletionCause completionCause) => { if (completionCause != DictationCompletionCause.Complete) { Debug.LogErrorFormat("Dictation completed unsuccessfully: {0}.", completionCause); } }); m_DictationRecognizer.DictationError += ((string error, int hresult) => { Debug.LogErrorFormat("Dictation error: {0}; HResult = {1}.", error, hresult); }); m_DictationRecognizer.Start(); m_Recognitions.text = ""; m_Hypotheses.text = ""; enableUI("StartDictation"); }
/// <summary> /// <c>start</c> /// /// Description: Builds data before game begins for Speech-to-text system /// /// Pre-condition: None /// /// Post-condition: set up the data required to run the dictationReconginzer. Once the /// dictationReconginzer is up and running we can begin logging what the player says. /// only need to set up this content once, so at beginning of play time we will do this. /// Once phrase is spoken, we will log it, and then send it to the dialogueTree. /// /// </summary> /// <returns>NULL</returns> public void Start() { dictationRecognizer = new DictationRecognizer(); // When speech has been recognized. dictationRecognizer.DictationResult += (text, confidence) => { phraseSpoken = text; // Write the text to the log. GameObject.FindGameObjectWithTag("Log").GetComponent <LogSystem>().WriteToFile(phraseSpoken); this.text.text = phraseSpoken; Debug.Log("what is inside the Phrase Spoken:" + phraseSpoken); //if (dialogueTree != null) //dialogueTree.inTree(phraseSpoken); }; text.gameObject.SetActive(false); if (Microphone.devices.Length == 0) { text.text = "Warning: There are no audio input devices connected!"; text.gameObject.SetActive(true); } dictationRecognizer.Start(); }
void Start() { m_DictationRecognizer = new DictationRecognizer(); m_DictationRecognizer.DictationResult += (text, confidence) => { Debug.LogFormat("Dictation result: {0}", text); //m_Recognitions.text += text + "\n"; }; m_DictationRecognizer.DictationHypothesis += (text) => { //Debug.LogFormat("Dictation hypothesis: {0}", text); //m_Hypotheses.text += text; }; m_DictationRecognizer.DictationComplete += (completionCause) => { if (completionCause != DictationCompletionCause.Complete) { Debug.LogErrorFormat("Dictation completed unsuccessfully: {0}.", completionCause); } }; m_DictationRecognizer.DictationError += (error, hresult) => { Debug.LogErrorFormat("Dictation error: {0}; HResult = {1}.", error, hresult); }; m_DictationRecognizer.Start(); }
public void StartRecording() { Debug.Log("START RECORDING DEBUG"); dictationRecognizer.Start(); this.text.text = "START!"; //return Microphone.Start(deviceName, true, messageLength, samplingRate); }
private IEnumerator _toggleDictation(bool state) { if (state) { keywordRecognizer.Stop(); PhraseRecognitionSystem.Shutdown(); while (PhraseRecognitionSystem.Status == SpeechSystemStatus.Running) { yield return(null); } dictationRecognizer.Start(); } else { dictationRecognizer.Stop(); while (dictationRecognizer.Status == SpeechSystemStatus.Running) { yield return(null); } PhraseRecognitionSystem.Restart(); keywordRecognizer.Start(); } }
public IEnumerator StartRecording() { //Debug.Log("Dictation Start!"); _dictationRecognizer.Start(); yield return(null); //Debug.Log("Dictation Stop!"); }
/// <summary> ############################################################ /// --------------------- Dictation Methods below ---------------------- /// </summary> ########################################################### public void noteTaking() { // stop keyword recognizer to prevent dictation recognition conflict PhraseRecognitionSystem.Shutdown(); Debug.Log("Shutting down Phrase Recognition"); dictationRecognizer = new DictationRecognizer(); dictationRecognizer.InitialSilenceTimeoutSeconds = 6f; dictationRecognizer.AutoSilenceTimeoutSeconds = 6f; dictationRecognizer.DictationResult += dictationRecognizer_DictationResult; dictationRecognizer.DictationHypothesis += dictationRecognizer_DictationHypothesis; dictationRecognizer.DictationComplete += dictationRecognizer_DictationComplete; dictationRecognizer.DictationError += dictationRecognizer_DictationError; // Used for debugging to show dictation parameters has been activated. // So, dictation can be used in App. Debug.Log("Initiliazed Dictation Recognizer"); // Start dictation recogntion dictationRecognizer.Start(); // Change bool to true for dictation control IsRunning = true; checkDictationOn(); // Used for debugging to show dictation recognizer has started. Debug.Log("Dictation started"); }
/// <summary> /// Starts the windows speech to text as a streaming service /// </summary> public override void EnableSpeechToText() { if (dictationRecognizer.Status != SpeechSystemStatus.Running) { dictationRecognizer.Start(); } }
public void StartSpeechToText() { // Only allow dictation if a microphone is available and attached to the GameObject // Don't allow more than one instance bool isOkayToRecord = true; if (Microphone.devices.Length < 1) { Debug.LogError("No microphone found!"); isOkayToRecord = false; } if (audioListener == null) { Debug.LogError("No audio listener found!"); isOkayToRecord = false; } if (dictationRecognizer == null) { Debug.LogError("No dictation recognizer found!"); isOkayToRecord = false; } if (dictationRecognizer != null && dictationRecognizer.Status.Equals(SpeechSystemStatus.Running)) { Debug.LogWarning("Dictation recognizer is already in use!"); isOkayToRecord = false; } // Launch the recognizer if (isOkayToRecord) { ResetResult(); dictationRecognizer.Start(); } }
void Start() { m_DictationRecognizer = new DictationRecognizer(); m_DictationRecognizer.DictationResult += (text, confidence) => { Debug.LogFormat("Dictation result: {0}", text); sprachAusgabe.SetWordsToSay(text); }; m_DictationRecognizer.DictationHypothesis += (text) => { Debug.LogFormat("Dictation hypothesis: {0}", text); }; m_DictationRecognizer.DictationComplete += (completionCause) => { if (completionCause != DictationCompletionCause.Complete) { Debug.LogErrorFormat("Dictation completed unsuccessfully: {0}.", completionCause); } }; m_DictationRecognizer.DictationError += (error, hresult) => { Debug.LogErrorFormat("Dictation error: {0}; HResult = {1}.", error, hresult); }; m_DictationRecognizer.Start(); }
void Start() { camera = GameObject.Find("Main Camera"); videoPlayer = camera.AddComponent <VideoPlayer>(); audioSource = gameObject.AddComponent <AudioSource>(); videoPlayer.audioOutputMode = VideoAudioOutputMode.AudioSource; videoPlayer.renderMode = UnityEngine.Video.VideoRenderMode.CameraNearPlane; videoPlayer.playOnAwake = false; videoPlayer.source = VideoSource.Url; gender = "Male"; dictationRecognizer = new DictationRecognizer(); dictationRecognizer.DictationHypothesis += (text) => { print(text); }; dictationRecognizer.DictationResult += (text, confidence) => { print(text + " - " + confidence); }; dictationRecognizer.Start(); palabrasClaves = new string[] { "Historia", "Fundado", "Francia" }; reconocedorDeVoz = new KeywordRecognizer(palabrasClaves); reconocedorDeVoz.OnPhraseRecognized += OnPhraseRecognized; reconocedorDeVoz.Start(); videoPlayer.loopPointReached += CheckOver; }
/// <summary> /// Turns on the dictation recognizer and begins recording audio from the default microphone. /// </summary> /// <returns>The audio clip recorded from the microphone.</returns> public void StartRecording() { // Start dictationRecognizer dictationRecognizer.Start(); Debug.Log("Dictation Recognizer is now " + ((dictationRecognizer.Status == SpeechSystemStatus.Running) ? "on" : "off")); }
public void Start() { m_DictationRecognizer = new DictationRecognizer(); m_DictationRecognizer.DictationResult += (text, confidence) => { Debug.LogFormat("Dictation result: {0}", text); m_Recognitions.text += text + "\n"; allspeech += text + " "; }; m_DictationRecognizer.DictationHypothesis += (text) => { Debug.LogFormat("Dictation hypothesis: {0}", text); m_Hypotheses.text += text; }; //m_DictationRecognizer.DictationComplete += (completionCause) => //{ // if (completionCause != DictationCompletionCause.Complete) // Debug.LogErrorFormat("Dictation completed unsuccessfully: {0}.", completionCause); //}; //m_DictationRecognizer.DictationError += (error, hresult) => //{ // Debug.LogErrorFormat("Dictation error: {0}; HResult = {1}.", error, hresult); //}; m_DictationRecognizer.InitialSilenceTimeoutSeconds = 300f; m_DictationRecognizer.AutoSilenceTimeoutSeconds = 300f; m_DictationRecognizer.Start(); }
public void StartListening() { Recognizer.DictationResult += (text, confindence) => { TextField.text = text; //Debug.LogFormat("Dictation result: {0}" + text); }; Recognizer.DictationHypothesis += (text) => { Debug.LogFormat("Dictation hypothesis: {0}", text); }; Recognizer.DictationComplete += (completeCause) => { if (completeCause != DictationCompletionCause.Complete) { Debug.LogErrorFormat("Dictation completed unsuccessfully: {0}.", completeCause); } }; Recognizer.DictationError += (error, result) => { Debug.LogErrorFormat("Dictation error: {0}; HResult = {1}.", error, result); }; Recognizer.Start(); }