public Alert(string alert, string url, RiskLevel risk, ConfidenceLevel confidence, string parameter, string other) : this(alert, url, risk, confidence) { this.Other = other; this.Parameter = parameter; }
public Alert(string alert, string url, RiskLevel risk, ConfidenceLevel confidence) : this(alert, url) { this.Risk = risk; this.Confidence = confidence; }
private IntPtr Create(ConfidenceLevel minimumConfidence, DictationTopicConstraint topicConstraint) { IntPtr result; DictationRecognizer.INTERNAL_CALL_Create(this, minimumConfidence, topicConstraint, out result); return(result); }
/// <summary> /// When windows recognizes text, this will be called. /// </summary> /// <param name="text">the text that was said</param> /// <param name="confidence">confidence of the recongized text</param> private void OnDictationResult(string text, ConfidenceLevel confidence) { Debug.Log(string.Format("SpeechToText::OnDictationResult: text: {0}, confidence: {1}", text, confidence)); // send the string to the lang engine Debug.Assert(LE != null); LE.RecieveInput(text); }
/// <summary> /// This event is fired after the user pauses, typically at the end of a sentence. The full recognized string is returned here. /// </summary> /// <param name="text">The text that was heard by the recognizer.</param> /// <param name="confidence">A representation of how confident (rejected, low, medium, high) the recognizer is of this recognition.</param> private void DictationRecognizer_DictationResult(string text, ConfidenceLevel confidence) { // 3.a: Append textSoFar with latest text textSoFar.Append(text + ". "); // 3.a: Set DictationDisplay text to be textSoFar speechText.GetComponent <TextMesh>().text = fixText(textSoFar.ToString()); }
internal PhraseRecognizedEventArgs(string text, ConfidenceLevel confidence, SemanticMeaning[] semanticMeanings, DateTime phraseStartTime, TimeSpan phraseDuration) { this.text = text; this.confidence = confidence; this.semanticMeanings = semanticMeanings; this.phraseStartTime = phraseStartTime; this.phraseDuration = phraseDuration; }
/// <summary> /// This event is fired after the user pauses, typically at the end of a sentence. The full recognized string is returned here. /// </summary> /// <param name="text">The text that was heard by the recognizer.</param> /// <param name="confidence">A representation of how confident (rejected, low, medium, high) the recognizer is of this recognition.</param> private static void DictationRecognizer_DictationResult(string text, ConfidenceLevel confidence) { textSoFar.Append($"{text}. "); dictationResult = textSoFar.ToString(); InputSystem.RaiseDictationResult(source, dictationResult); }
/// <summary> /// This event is fired after the user pauses, typically at the end of a sentence. The full recognized string is returned here. /// </summary> /// <param Name="text">The text that was heard by the recognizer.</param> /// <param Name="confidence">A representation of how confident (rejected, low, medium, high) the recognizer is of this recognition.</param> private static void DictationRecognizer_DictationResult(string text, ConfidenceLevel confidence) { textSoFar.Append(text + ". "); dictationResult = textSoFar.ToString(); InputManager.Instance.RaiseDictationResult(Instance, 0, dictationResult); }
private void dictationRecognizer_DictationResult(string text, ConfidenceLevel confidence) { // Displays what the App belives was spoken and displays it in console Debug.LogFormat("Dictation result: {0}", text); // Displays what was said to the UI dictationDisplay.text = text; }
/// <summary> /// Calculates Z value (z-star) for confidence interval /// </summary> /// <param name="level">ConfidenceLevel for a confidence interval</param> /// <param name="n">Sample size (n >= 3)</param> public static double GetZValue(this ConfidenceLevel level, int n) { if (n <= 2) { throw new ArgumentOutOfRangeException(nameof(n), "n should be >= 3"); } return(MathHelper.InverseStudent(1 - level.ToPercent(), n - 1)); }
private void InvokePhraseRecognizedEvent(string text, ConfidenceLevel confidence, SemanticMeaning[] semanticMeanings, long phraseStartFileTime, long phraseDurationTicks) { PhraseRecognizedDelegate onPhraseRecognized = this.OnPhraseRecognized; if (onPhraseRecognized != null) { onPhraseRecognized(new PhraseRecognizedEventArgs(text, confidence, semanticMeanings, DateTime.FromFileTime(phraseStartFileTime), TimeSpan.FromTicks(phraseDurationTicks))); } }
public SpeechKeywordRecognizedEventArgs(IInputSource inputSource, uint sourceId, ConfidenceLevel confidence, TimeSpan phraseDuration, DateTime phraseStartTime, SemanticMeaning[] semanticMeanings, string recognizedText) : base(inputSource, sourceId) { Confidence = confidence; PhraseDuration = phraseDuration; PhraseStartTime = phraseStartTime; SemanticMeanings = semanticMeanings; RecognizedText = recognizedText; }
private void InvokePhraseRecognizedEvent(string text, ConfidenceLevel confidence, SemanticMeaning[] semanticMeanings, long phraseStartFileTime, long phraseDurationTicks) { PhraseRecognizer.PhraseRecognizedDelegate onPhraseRecognized = this.OnPhraseRecognized; if (onPhraseRecognized != null) { onPhraseRecognized(new PhraseRecognizedEventArgs(text, confidence, semanticMeanings, DateTime.FromFileTime(phraseStartFileTime), TimeSpan.FromTicks(phraseDurationTicks))); } }
public void ComputeConfidenceIntervals(ConfidenceLevel level) { var se = GetFittingErrors(); var tstat = TStat(level); SlopeError = se.Item1 * tstat; InterceptError = se.Item2 * tstat; }
/// <summary> /// This handler is called every time the Dictation detects a pause in the speech. /// Debugging message is delivered to the Results class. /// </summary> private void DictationRecognizer_DictationResult(string text, ConfidenceLevel confidence) { // Update UI with dictation captured Results.instance.SetSubtitleContent(text); // Start the coroutine that process the dictation through Azure //StartCoroutine(Translator.instance.TranslateWithUnityNetworking(text)); }
/// <summary> /// This event is fired after the user pauses, typically at the end of a sentence. The full recognized string is returned here. /// </summary> /// <param name="text">The text that was heard by the recognizer.</param> /// <param name="confidence">A representation of how confident (rejected, low, medium, high) the recognizer is of this recognition.</param> private void DictationRecognizer_DictationResult(string text, ConfidenceLevel confidence) { // 3.a: Append textSoFar with latest text textSoFar.Append(text + ". "); // 3.a: Set DictationDisplay text to be textSoFar DictationDisplay.text = textSoFar.ToString(); }
/// <summary> /// This event is fired after the user pauses, typically at the end of a sentence. The full recognized string is returned here. /// </summary> /// <param name="text">The text that was heard by the recognizer.</param> /// <param name="confidence">A representation of how confident (rejected, low, medium, high) the recognizer is of this recognition.</param> private void DictationRecognizer_DictationResult(string text, ConfidenceLevel confidence) { textSoFar.Append($"{text}. "); dictationResult = textSoFar.ToString(); MixedRealityToolkit.InputSystem.RaiseDictationResult(inputSource, dictationResult); }
protected void OnPhraseRecognized(ConfidenceLevel confidence, TimeSpan phraseDuration, DateTime phraseStartTime, SemanticMeaning[] semanticMeanings, string text) { // Create input event speechKeywordRecognizedEventData.Initialize(this, 0, confidence, phraseDuration, phraseStartTime, semanticMeanings, text); // Pass handler through HandleEvent to perform modal/fallback logic inputManager.HandleEvent(speechKeywordRecognizedEventData, OnSpeechKeywordRecognizedEventHandler); }
/// <summary> /// Event fired when dictation completed. /// </summary> /// <param name="text">Speech to Text</param> /// <param name="confidence">Confidence dictation has in it's translation.</param> private void OnDictationResult(string text, ConfidenceLevel confidence) { if (text != null) { InputField.text.Insert(InputField.caretPosition, text); InputField.caretPosition += text.Length; } }
/// <summary> /// A listener for when the DictationRecognizer had finalized its prediction /// And has transcribed the recorded text as a result. Adds that to recordedText. /// Updates the dictation listeners with all the recorded text so far. /// </summary> /// <param name="text">The final recorded text returned by the DictationRecognizer</param> /// <param name="confidence">How confident the DR is in the text being accurate</param> public void DictationRecognizer_DictationResult(string text, ConfidenceLevel confidence) { recordedText += text + " "; foreach (DictationListener dictationListener in DictationListeners) { dictationListener.UpdateRecorded(recordedText); } }
/* What to do on a recognized utterance from user */ private void DictationRecognizer_DictationResult(string text, ConfidenceLevel conf) { //on a recognized dictation from user... wild.finish(); dictationRecognizer.DictationResult -= DictationRecognizer_DictationResult; Debug.Log(TAG + "Dictation result: " + text + " @confidence= " + conf); }
//DictationResult:音声が特定の認識精度で認識されたときに発生するイベント private void DictationRecognizer_DictationResult(string text, ConfidenceLevel confidence) { animReticle.SetBool("VoiceInput", true); //音声認識アニメーション終了 ///animReticle.SetBool("VoiceInput", false); //Debug.Log("認識した音声:" + text); inputText = text; }
private void DictationRecognizer_InvokeResultGeneratedEvent(string keyword, ConfidenceLevel minimumConfidence) { DictationRecognizer.DictationResultDelegate dictationResult = this.DictationResult; if (dictationResult != null) { dictationResult(keyword, minimumConfidence); } }
private void DictationRecognizer_InvokeResultGeneratedEvent(string keyword, ConfidenceLevel minimumConfidence) { var handler = DictationResult; if (handler != null) { handler(keyword, minimumConfidence); } }
public ConfidenceInterval(double mean, double error, ConfidenceLevel level = ConfidenceLevel.L95) { Mean = mean; Error = error; Level = level; Margin = error * ZValues[level]; Lower = mean - Margin; Upper = mean + Margin; }
/// <summary> /// Function that is called when a final text result is received. /// </summary> /// <param name="text">The final text result</param> /// <param name="confidence">Confidence level of the text result</param> void OnDictationResult(string text, ConfidenceLevel confidence) { SmartLogger.LogFormat(DebugFlags.WindowsSpeechToText, "Dictation result: {0}", text); m_LastResult = new SpeechToTextResult(text, true); if (m_OnTextResult != null) { m_OnTextResult(m_LastResult); } }
/// <summary> /// This event is fired after the user pauses, typically at the end of a sentence. The full recognized string is returned here. /// </summary> /// <param name="text">The text that was heard by the recognizer.</param> /// <param name="confidence">A representation of how confident (rejected, low, medium, high) the recognizer is of this recognition.</param> private void DictationRecognizer_DictationResult(string text, ConfidenceLevel confidence) { textSoFar.Append(text + ". "); dictationResult = textSoFar.ToString(); speechToTextOutput.text = text; LUIS.GetLuisPrediction(text); }
/// <summary> /// This handler is called every time the Dictation detects a pause in the speech. /// </summary> private void DictationRecognizer_DictationResult(string text, ConfidenceLevel confidence) { // Update UI with dictation captured Debug.Log($"User just said: {text}"); // Send dictation to Bot StartCoroutine(SendMessageToBot(text, botId, botName, "message")); StopCapturingAudio(); }
private void DictationRecognizer_DictationResult(string text, ConfidenceLevel confidence) { GameObject holoMenu = null; Debug.Log("String heard: " + text); dictationRecognizer.Stop(); // Cases to set holoMenu to the correct menu if (text.ToLower().Equals("main") || text.ToLower().Equals("main menu") || text.ToLower().Equals("maine") || text.ToLower().Equals("mean")) { holoMenu = mc.m_mainMenu; } else if (text.ToLower().Equals("biometrics")) { holoMenu = mc.m_biometricsMenu; } else if (text.ToLower().Equals("help")) { holoMenu = mc.m_helpMenu; } else if (text.ToLower().Equals("music")) { holoMenu = mc.m_musicMenu; } else if (text.ToLower().Equals("settings")) { holoMenu = mc.m_settingsMenu; } else if (text.ToLower().Equals("brightness")) { holoMenu = mc.m_brightnessMenu; } else if (text.ToLower().Equals("volume")) { holoMenu = mc.m_volumeMenu; } else if (text.ToLower().Equals("procedure")) { holoMenu = mc.m_blankTaskMenu; } else { Debug.Log("Cmd not recognized."); // This does not fail eloquently } // call function in MenuController to retrieve the specific menu if (holoMenu != null) { mc.Retrieve(holoMenu); } dictationRecognizer.Dispose(); PhraseRecognitionSystem.Restart(); }
/// <summary> /// Populates the event with data. /// </summary> /// <param name="inputSource"></param> /// <param name="inputAction"></param> /// <param name="confidence"></param> /// <param name="phraseDuration"></param> /// <param name="phraseStartTime"></param> /// <param name="semanticMeanings"></param> /// <param name="recognizedText"></param> public void Initialize(IMixedRealityInputSource inputSource, MixedRealityInputAction inputAction, ConfidenceLevel confidence, TimeSpan phraseDuration, DateTime phraseStartTime, SemanticMeaning[] semanticMeanings, string recognizedText) { BaseInitialize(inputSource, inputAction); Confidence = confidence; PhraseDuration = phraseDuration; PhraseStartTime = phraseStartTime; SemanticMeanings = semanticMeanings; RecognizedText = recognizedText; }
public void Initialize(IInputSource inputSource, uint sourceId, object tag, ConfidenceLevel confidence, TimeSpan phraseDuration, DateTime phraseStartTime, SemanticMeaning[] semanticMeanings, string recognizedText) { BaseInitialize(inputSource, sourceId, tag); Confidence = confidence; PhraseDuration = phraseDuration; PhraseStartTime = phraseStartTime; SemanticMeanings = semanticMeanings; RecognizedText = recognizedText; }
public BingAddress(string formattedAddress, Location coordinates, string addressLine, string adminDistrict, string adminDistrict2, string countryRegion, string locality, string postalCode, EntityType type, ConfidenceLevel confidence) : base(formattedAddress, coordinates, "Bing") { this.addressLine = addressLine; this.adminDistrict = adminDistrict; this.adminDistrict2 = adminDistrict2; this.countryRegion = countryRegion; this.locality = locality; this.postalCode = postalCode; this.type = type; this.confidence = confidence; }
public Alert(string alert, string url, RiskLevel risk, ConfidenceLevel confidence, string parameter, string other, string attack, string description, string reference, string solution, string evidence, int cweId, int wascId) : this(alert, url, risk, confidence, parameter, other) { this.Attack = attack; this.Description = description; this.Reference = reference; this.Solution = solution; this.Evidence = evidence; this.CWEId = cweId; this.WASCId = wascId; }
private void DictationRecognizer_InvokeResultGeneratedEvent(string keyword, ConfidenceLevel minimumConfidence) { DictationResultDelegate dictationResult = this.DictationResult; if (dictationResult != null) { dictationResult(keyword, minimumConfidence); } }
public static IColumn CiUpper(ConfidenceLevel level) => new StatisticColumn($"CI {level.ToPercent()}% Upper", s => new ConfidenceInterval(s.Mean, s.StandardError, level).Upper);
/// <summary> /// Overloaded constructor /// </summary> /// <param name="statistics">Basic statistics for data</param> /// <param name="level">Chosen confidence level</param> public ConfidenceIntervalStandardNormal(BasicStatistics statistics, ConfidenceLevel level) { this.statistics = statistics; this.level = level; }
/// <summary> /// Creates a confidence query string parameter. /// </summary> /// <param name="confidence">The value to use in the confidence query string parameter. See remarks.</param> /// <returns>A confidence query string parameter.</returns> /// <remarks> /// This could be used, for example, to specify the level of confidence required during certain merge operations. /// </remarks> public static QueryParameter Confidence(ConfidenceLevel confidence) { return new QueryParameter(true, CONFIDENCE, XmlQNameEnumUtil.GetNameValue(confidence)); }
/// <summary> /// <para>Create a DictationRecognizer with the specified minimum confidence and dictation topic constraint. Phrases under the specified minimum level will be ignored.</para> /// </summary> /// <param name="minimumConfidence">The confidence level at which the recognizer will begin accepting phrases.</param> /// <param name="topic">The dictation topic that this dictation recognizer should optimize its recognition for.</param> /// <param name="confidenceLevel"></param> public DictationRecognizer(ConfidenceLevel minimumConfidence, DictationTopicConstraint topic) { this.m_Recognizer = this.Create(minimumConfidence, topic); }
/// <summary> /// Constructor /// </summary> /// <param name="statsVariable1">Statistics object for variable 1</param> /// <param name="statsVariable2">Statistics object for variable 2</param> public ConfidenceIntervalForMeanDifference(BasicStatistics statsVariable1, BasicStatistics statsVariable2) { this.statsVariable1 = statsVariable1; this.statsVariable2 = statsVariable2; this.level = ConfidenceLevel.NinetyFive; }
/// <summary> /// Overloaded constructor /// </summary> /// <param name="statsVariable1">Statistics object for variable 1</param> /// <param name="statsVariable2">Statistics object for variable 2</param> /// <param name="level">Chosen confidence level</param> public ConfidenceIntervalForMeanDifference(BasicStatistics statsVariable1, BasicStatistics statsVariable2, ConfidenceLevel level) { this.statsVariable1 = statsVariable1; this.statsVariable2 = statsVariable2; this.level = level; }
public static IColumn CiLower(ConfidenceLevel level) => new StatisticColumn($"CI {level.ToPercent()}% Lower", s => new ConfidenceInterval(s.Mean, s.StandardError, level).Lower, Priority.Additional);
private static extern void INTERNAL_CALL_Create(DictationRecognizer self, ConfidenceLevel minimumConfidence, DictationTopicConstraint topicConstraint, out IntPtr value);
private static extern void INTERNAL_CALL_CreateFromKeywords(PhraseRecognizer self, string[] keywords, ConfidenceLevel minimumConfidence, out IntPtr value);
/// <summary> /// <para>Create a DictationRecognizer with the specified minimum confidence and dictation topic constraint. Phrases under the specified minimum level will be ignored.</para> /// </summary> /// <param name="minimumConfidence">The confidence level at which the recognizer will begin accepting phrases.</param> /// <param name="topic">The dictation topic that this dictation recognizer should optimize its recognition for.</param> /// <param name="confidenceLevel"></param> public DictationRecognizer(ConfidenceLevel confidenceLevel) : this(confidenceLevel, DictationTopicConstraint.Dictation) { }
private static extern void INTERNAL_CALL_CreateFromGrammarFile(PhraseRecognizer self, string grammarFilePath, ConfidenceLevel minimumConfidence, out IntPtr value);
private IntPtr Create(ConfidenceLevel minimumConfidence, DictationTopicConstraint topicConstraint) { IntPtr ptr; INTERNAL_CALL_Create(this, minimumConfidence, topicConstraint, out ptr); return ptr; }
protected IntPtr CreateFromKeywords(string[] keywords, ConfidenceLevel minimumConfidence) { IntPtr ptr; INTERNAL_CALL_CreateFromKeywords(this, keywords, minimumConfidence, out ptr); return ptr; }
/// <summary> /// Constructor: assumes 95% confidence level /// </summary> /// <param name="statistics">Basic statistics for data</param> public ConfidenceIntervalStandardNormal(BasicStatistics statistics) { this.statistics = statistics; this.level = ConfidenceLevel.NinetyFive; }
protected IntPtr CreateFromGrammarFile(string grammarFilePath, ConfidenceLevel minimumConfidence) { IntPtr ptr; INTERNAL_CALL_CreateFromGrammarFile(this, grammarFilePath, minimumConfidence, out ptr); return ptr; }
public ConfidenceInterval GetConfidenceInterval(ConfidenceLevel level) => new ConfidenceInterval(Mean, StandardError, level);
/** * Build up this conclusion with a confidence level. * * @param confidence The confidence level. * @return this. */ public Conclusion SetConfidence(ConfidenceLevel confidence) { KnownConfidence = confidence; return this; }