HoloLens (1. Generation) Input 212: Voice

Wichtig

Die Tutorials der Mixed Reality Academy wurden unter Berücksichtigung von HoloLens (1. Generation), Unity 2017 und Mixed Reality Immersive Headsets entwickelt. Daher halten wir es für wichtig, diese Tutorials für Entwickler verfügbar zu halten, die noch nach Anleitung beim Entwickeln für diese Geräte suchen. Diese Tutorials werden nicht mit den neuesten Toolsets oder Interaktionen aktualisiert, die für HoloLens 2 verwendet werden, und sind möglicherweise nicht mit neueren Versionen von Unity kompatibel. Sie werden gewartet, um weiterhin auf den unterstützten Geräten zu funktionieren. Es wurde eine neue Reihe von Tutorials für HoloLens 2 veröffentlicht.

Die Spracheingabe bietet uns eine weitere Möglichkeit, mit unseren Hologrammen zu interagieren. Sprachbefehle funktionieren auf sehr natürliche und einfache Weise. Entwerfen Sie Ihre Sprachbefehle so, dass sie wie folgt sind:

• Natural
• Leicht zu merken
• Kontextgerecht
• Hinreichende Abgrenzung von anderen Optionen innerhalb desselben Kontexts

In MR Basics 101 haben wir den KeywordRecognizer verwendet, um zwei einfache Sprachbefehle zu erstellen. In MR Input 212 erfahren Sie, wie Sie:

• Entwerfen Sie Sprachbefehle, die für die HoloLens-Sprach-Engine optimiert sind.
• Informieren Sie den Benutzer darüber, welche Sprachbefehle verfügbar sind.
• Bestätigen Sie, dass wir den Sprachbefehl des Benutzers gehört haben.
• Verstehen Sie, was der Benutzer sagt, indem Sie eine Diktiererkennung verwenden.
• Verwenden Sie eine Grammatikerkennung, um auf Befehlen zu lauschen, die auf einer SRGS- oder Spracherkennungsgrammatik-Datei basieren.

In diesem Kurs wird das Modell Explorer, das wir in MR Input 210 und MR Input 211 erstellt haben, erneut behandelt.

Wichtig

Die in die folgenden Kapitel eingebetteten Videos wurden mit einer älteren Version von Unity und dem Mixed Reality Toolkit aufgezeichnet. Obwohl die Schritt-für-Schritt-Anweisungen genau und aktuell sind, werden möglicherweise Skripts und Visuals in den entsprechenden Videos angezeigt, die veraltet sind. Die Videos bleiben für die Nachwelt und da die behandelten Konzepte weiterhin gelten.

Geräteunterstützung

Kurs	HoloLens	Immersive Headsets
MR-Eingabe 212: Sprache	✔️	✔️

Vorbereitung

Voraussetzungen

• Ein Windows 10 PC, der mit den richtigen Installierten Tools konfiguriert ist.
• Einige grundlegende C#-Programmierfunktionen.
• Sie sollten MR-Grundlagen 101 abgeschlossen haben.
• Sie sollten mr Input 210 abgeschlossen haben.
• Sie sollten MR-Eingabe 211 abgeschlossen haben.
• Ein HoloLens-Gerät , das für die Entwicklung konfiguriert ist.

Projektdateien

• Laden Sie die für das Projekt erforderlichen Dateien herunter. Erfordert Unity 2017.2 oder höher.
• Heben Sie die Archivierung der Dateien auf Ihrem Desktop oder einem anderen leicht erreichbaren Speicherort auf.

Hinweis

Wenn Sie den Quellcode vor dem Herunterladen durchsuchen möchten, ist er auf GitHub verfügbar.

Errata und Notizen

• "Nur eigenen Code aktivieren" muss in Visual Studio unter Tools-Options-Debugging>> deaktiviert (deaktiviert) werden, um Haltepunkte im Code zu erreichen.

Unity-Setup

Anweisungen

1. Starten Sie Unity.
2. Klicken Sie auf Öffnen.
3. Navigieren Sie zum Ordner HolographicAcademy-Holograms-212-Voice , den Sie zuvor nicht archiviert haben.
4. Suchen Sie den Ordner Startmodell/Explorer, und wählen Sie sie aus.
5. Klicken Sie auf die Schaltfläche Ordner auswählen .
6. Erweitern Sie im Projektbereich den Ordner Szenen .
7. Doppelklicken Sie auf ModelExplorer-Szene , um sie in Unity zu laden.

Erstellen

1. Wählen Sie in Unity Dateibuildeinstellungen >aus.
2. Wenn Scenes/ModelExplorer in Scenes In Build nicht aufgeführt ist, klicken Sie auf Offene Szenen hinzufügen , um die Szene hinzuzufügen.
3. Wenn Sie speziell für HoloLens entwickeln, legen Sie Zielgerät auf HoloLens fest. Andernfalls behalten Sie die Option "Beliebiges Gerät" bei.
4. Stellen Sie sicher , dass Buildtyp auf D3D und SDK auf Latest installed (dies sollte SDK 16299 oder höher sein) festgelegt ist.
5. Klicken Sie auf Erstellen.
6. Erstellen Sie einen neuen Ordner mit dem Namen "App".
7. Klicken Sie auf den Ordner App .
8. Klicken Sie auf Ordner auswählen , und Unity beginnt mit der Erstellung des Projekts für Visual Studio.

Wenn Unity fertig ist, wird ein Explorer Fenster angezeigt.

1. Öffnen Sie den Ordner App .
2. Öffnen Sie die Visual Studio-Projektmappe ModelExplorer.

Bei der Bereitstellung in HoloLens:

1. Ändern Sie mithilfe der oberen Symbolleiste in Visual Studio das Ziel von Debuggen in Release und von ARM in x86.
2. Klicken Sie auf den Dropdownpfeil neben der Schaltfläche Lokaler Computer, und wählen Sie Remotecomputer aus.
3. Geben Sie die IP-Adresse Ihres HoloLens-Geräts ein, und legen Sie den Authentifizierungsmodus auf Universal (Unverschlüsseltes Protokoll) fest. Klicken Sie auf Auswählen. Wenn Sie Ihre Geräte-IP-Adresse nicht kennen, suchen Sie unter Einstellungen > Netzwerk & Internet > Erweiterte Optionen.
4. Klicken Sie in der oberen Menüleiste auf Debuggen –> Ohne Debuggen starten , oder drücken Sie STRG+F5. Wenn sie zum ersten Mal auf Ihrem Gerät bereitgestellt werden, müssen Sie es mit Visual Studio koppeln.
5. Wenn die App bereitgestellt wurde, schließen Sie das Fitbox-Element mit einer Auswahlgeste.

Bei der Bereitstellung auf einem immersiven Headset:

1. Ändern Sie mithilfe der oberen Symbolleiste in Visual Studio das Ziel von Debuggen in Release und von ARM in x64.
2. Stellen Sie sicher, dass das Bereitstellungsziel auf Lokaler Computer festgelegt ist.
3. Klicken Sie in der oberen Menüleiste auf Debuggen –> Ohne Debuggen starten , oder drücken Sie STRG+F5.
4. Wenn die App bereitgestellt wurde, schließen Sie die Fitbox , indem Sie den Trigger auf einen Bewegungscontroller ziehen.

Hinweis

Im Bereich "Fehler" von Visual Studio werden möglicherweise einige rote Fehler festgestellt. Es ist sicher, sie zu ignorieren. Wechseln Sie zum Ausgabebereich, um den tatsächlichen Buildfortschritt anzuzeigen. Fehler im Ausgabebereich erfordern eine Korrektur (meistens werden sie durch einen Fehler in einem Skript verursacht).

Kapitel 1 – Bewusstsein

Ziele

• Lernen Sie die Dos und Don'ts des Sprachbefehlsentwurfs kennen.
• Verwenden Sie KeywordRecognizer , um sprachbasierte Sprachbefehle hinzuzufügen.
• Machen Sie Benutzer mithilfe von Cursorfeedback auf Sprachbefehle aufmerksam.

Sprachbefehlsentwurf

In diesem Kapitel erfahren Sie mehr über das Entwerfen von Sprachbefehlen. Beim Erstellen von Sprachbefehlen:

DO

• Erstellen Sie präzise Befehle. Sie möchten nicht "Wiedergabe des aktuell ausgewählten Videos" verwenden, da dieser Befehl nicht prägnant ist und vom Benutzer leicht vergessen werden würde. Stattdessen sollten Sie Folgendes verwenden: "Video wiedergeben", da es prägnant ist und mehrere Silben aufweist.
• Verwenden Sie ein einfaches Vokabular. Versuchen Sie immer, allgemeine Wörter und Ausdrücke zu verwenden, die für den Benutzer leicht zu erkennen und zu merken sind. Wenn Ihre Anwendung beispielsweise über ein Notizobjekt verfügt, das in der Ansicht angezeigt oder ausgeblendet werden könnte, würden Sie den Befehl "Placard anzeigen" nicht verwenden, da "Placard" ein selten verwendeter Begriff ist. Stattdessen verwenden Sie den Befehl "Notiz anzeigen", um die Notiz in Ihrer Anwendung anzuzeigen.
• Achten Sie auf Einheitlichkeit. Sprachbefehle sollten in Ihrer gesamten Anwendung konsistent bleiben. Stellen Sie sich vor, Sie haben zwei Szenen in Ihrer Anwendung und beide Szenen enthalten eine Schaltfläche zum Schließen der Anwendung. Wenn die erste Szene den Befehl "Exit" verwendet hat, um die Schaltfläche auszulösen, aber in der zweiten Szene der Befehl "App schließen", wird der Benutzer sehr verwirrt. Wenn dieselbe Funktionalität über mehrere Szenen hinweg beibehalten wird, sollte derselbe Sprachbefehl verwendet werden, um sie auszulösen.

TUE NICHT

• Verwenden Sie einzelne Silbenbefehle. Wenn Sie beispielsweise einen Sprachbefehl zum Wiedergeben eines Videos erstellen, sollten Sie die Verwendung des einfachen Befehls "Wiedergabe" vermeiden, da es sich nur um eine einzelne Silbe handelt und vom System leicht übersehen werden könnte. Stattdessen sollten Sie Folgendes verwenden: "Video wiedergeben", da es prägnant ist und mehrere Silben aufweist.
• Verwenden Sie Systembefehle. Der Befehl "Select" wird vom System reserviert, um ein Tap-Ereignis für das aktuell fokussierte Objekt auszulösen. Verwenden Sie den Befehl "Auswählen" in einem Schlüsselwort (keyword) oder Ausdruck nicht erneut, da er möglicherweise nicht wie erwartet funktioniert. Wenn beispielsweise der Sprachbefehl für die Auswahl eines Cubes in Ihrer Anwendung "Cube auswählen" lautet, der Benutzer sich jedoch eine Kugel anschaute, als er den Befehl aussprach, wurde stattdessen die Kugel ausgewählt. Auf ähnliche Weise sind App-Leiste-Befehle sprachaktiviert. Verwenden Sie nicht die folgenden Sprachbefehle in Ihrer CoreWindow-Ansicht:
  1. Zurück
  2. Scroll-Tool
  3. Zoomtool
  4. Tool ziehen
  5. Anpassen
  6. Remove (Entfernen)
• Verwenden Sie ähnliche Sounds. Versuchen Sie, die Verwendung von Sprachbefehlen zu vermeiden, die sich reimen. Wenn Sie eine Einkaufsanwendung hatten, die "Store anzeigen" und "Mehr anzeigen" als Sprachbefehle unterstützte, sollten Sie einen der Befehle deaktivieren, während der andere verwendet wurde. Sie könnten beispielsweise die Schaltfläche "Store anzeigen" verwenden, um den Store zu öffnen und dann diesen Befehl zu deaktivieren, wenn der Store angezeigt wurde, sodass der Befehl "Mehr anzeigen" zum Durchsuchen verwendet werden konnte.

Anweisungen

• Verwenden Sie im Hierarchiebereich von Unity das Suchtool, um das holoComm_screen_mesh-Objekt zu finden.
• Doppelklicken Sie auf das holoComm_screen_mesh-Objekt , um es in der Szene anzuzeigen. Dies ist die watch des Astronauten, die auf unsere Sprachbefehle reagieren wird.
• Suchen Sie im Bereich Inspector nach der Komponente Speech Input Source (Script).
• Erweitern Sie den Abschnitt Schlüsselwörter , um den unterstützten Sprachbefehl anzuzeigen: Öffnen Sie Communicator.
• Klicken Sie rechts auf das Zahnrad, und wählen Sie dann Skript bearbeiten aus.
• Erkunden Sie SpeechInputSource.cs , um zu verstehen, wie der KeywordRecognizer zum Hinzufügen von Sprachbefehlen verwendet wird.

Erstellen und Bereitstellen

• Verwenden Sie in Unity die Dateibuildeinstellungen>, um die Anwendung neu zu erstellen.
• Öffnen Sie den Ordner App .
• Öffnen Sie die Visual Studio-Projektmappe ModelExplorer.

(Wenn Sie dieses Projekt bereits während der Einrichtung in Visual Studio erstellt/bereitgestellt haben, können Sie diese instance von VS öffnen und bei Aufforderung auf "Alle neu laden" klicken.)

• Klicken Sie in Visual Studio auf Debuggen –> Ohne Debuggen starten , oder drücken Sie STRG + F5.
• Nachdem die Anwendung in der HoloLens bereitgestellt wurde, schließen Sie das Anpassungsfeld mit der Luft tippen-Geste .
• Blicken Sie auf die watch des Astronauten.
• Wenn der watch den Fokus hat, vergewissern Sie sich, dass sich der Cursor in ein Mikrofon ändert. Dies gibt Feedback, dass die Anwendung Sprachbefehle lauscht.
• Vergewissern Sie sich, dass eine QuickInfo auf dem watch angezeigt wird. Dadurch können Benutzer den Befehl "Communicator öffnen" ermitteln.
• Wenn Sie die watch betrachten, sagen Sie "Communicator öffnen", um das Communicator-Panel zu öffnen.

Kapitel 2 : Bestätigung

Ziele

• Zeichnen Sie eine Nachricht mit der Mikrofoneingabe auf.
• Geben Sie dem Benutzer Feedback, dass die Anwendung auf ihre Stimme lauscht.

Hinweis

Die Mikrofonfunktion muss deklariert werden, damit eine App vom Mikrofon aufzeichnen kann. Dies geschieht für Sie bereits in MR Input 212, aber beachten Sie dies für Ihre eigenen Projekte.

1. Navigieren Sie im Unity-Editor zu den Playereinstellungen, indem Sie zu "Projekteinstellungen-Player > bearbeiten>" navigieren.
2. Klicken Sie auf die Registerkarte "Universelle Windows-Plattform".
3. Überprüfen Sie im Abschnitt "Funktionen für Veröffentlichungseinstellungen>" die Mikrofonfunktion

Anweisungen

• Vergewissern Sie sich im Bereich Hierarchie von Unity, dass das holoComm_screen_mesh-Objekt ausgewählt ist.
• Suchen Sie im Bereich Inspektor nach der Komponente Astronaut Watch (Script).
• Klicken Sie auf den kleinen blauen Cube, der als Wert der Communicator Prefab-Eigenschaft festgelegt ist.
• Im Projektbereich sollte das Communicator-Prefab nun den Fokus haben.
• Klicken Sie im Bereich Projekt auf das Communicator-Prefab, um seine Komponenten im Inspector anzuzeigen.
• Sehen Sie sich die Komponente Mikrofon-Manager (Skript) an. Dadurch können wir die Stimme des Benutzers aufzeichnen.
• Beachten Sie, dass das Communicator-Objekt über eine Speech Input Handler (Script)- Komponente zum Reagieren auf den Befehl Nachricht senden verfügt.
• Sehen Sie sich die Communicator -Komponente (Skript) an, und doppelklicken Sie auf das Skript, um es in Visual Studio zu öffnen.

Communicator.cs ist für das Festlegen der richtigen Schaltflächenzustände auf dem Communicator-Gerät verantwortlich. Dies ermöglicht es unseren Benutzern, eine Nachricht aufzuzeichnen, sie wiederzugeben und die Nachricht an den Astronauten zu senden. Es wird auch eine animierte Wellenform gestartet und beendet, um dem Benutzer zu bestätigen, dass seine Stimme gehört wurde.

• Löschen Sie in Communicator.cs die folgenden Zeilen (81 und 82) aus der Start-Methode . Dadurch wird die Schaltfläche "Aufzeichnen" auf dem Kommunikator aktiviert.

// TODO: 2.a Delete the following two lines:
RecordButton.SetActive(false);
MessageUIRenderer.gameObject.SetActive(false);

Erstellen und Bereitstellen

• Erstellen Sie in Visual Studio Ihre Anwendung neu, und stellen Sie sie auf dem Gerät bereit.
• Schauen Sie auf die watch des Astronauten und sagen Sie "Open Communicator", um den Kommunikator zu zeigen.
• Drücken Sie die Aufnahmetaste (Mikrofon), um die Aufzeichnung einer verbalen Nachricht für den Astronauten zu starten.
• Beginnen Sie mit dem Sprechen, und überprüfen Sie, ob die Wellenanimation auf dem Kommunikator wiedergegeben wird, was dem Benutzer Feedback gibt, dass seine Stimme gehört wird.
• Drücken Sie die Schaltfläche Beenden (linkes Quadrat), und vergewissern Sie sich, dass die Wellenanimation nicht mehr ausgeführt wird.
• Drücken Sie die Wiedergabetaste (rechtes Dreieck), um die aufgezeichnete Nachricht wiederzugeben und auf dem Gerät zu hören.
• Drücken Sie die Schaltfläche Beenden (rechtes Quadrat), um die Wiedergabe der aufgezeichneten Nachricht zu beenden.
• Sagen Sie "Nachricht senden" , um den Kommunikator zu schließen und die Antwort "Nachricht empfangen" vom Astronauten zu erhalten.

Kapitel 3: Grundlegendes und die Diktiererkennung

Ziele

• Verwenden Sie die Diktiererkennung, um die Sprache des Benutzers in Text zu konvertieren.
• Zeigen Sie die hypothetischen und endgültigen Ergebnisse der Diktiererkennung im Kommunikator an.

In diesem Kapitel verwenden wir die Diktiererkennung, um eine Nachricht für den Astronauten zu erstellen. Beachten Sie bei Verwendung der Diktiererkennung Folgendes:

• Sie müssen mit dem WLAN verbunden sein, damit die Diktiererkennung funktioniert.
• Timeouts treten nach einem bestimmten Zeitraum auf. Es gibt zwei Timeouts, die beachtet werden müssen:
  • Wenn die Erkennung startet und in den ersten fünf Sekunden kein Audio hört, wird ein Timeout ausgeführt.
  • Wenn die Erkennung ein Ergebnis angegeben hat, dann aber zwanzig Sekunden lang Stille hört, wird ein Timeout ausgeführt.
• Nur ein Erkennungstyp (Schlüsselwort oder Diktat) kann gleichzeitig ausgeführt werden.

Hinweis

Die Mikrofonfunktion muss deklariert werden, damit eine App vom Mikrofon aufzeichnen kann. Dies geschieht für Sie bereits in MR Input 212, aber beachten Sie dies für Ihre eigenen Projekte.

1. Navigieren Sie im Unity-Editor zu den Playereinstellungen, indem Sie zu "Projekteinstellungen-Player > bearbeiten>" navigieren.
2. Klicken Sie auf die Registerkarte "Universelle Windows-Plattform".
3. Überprüfen Sie im Abschnitt "Funktionen für Veröffentlichungseinstellungen>" die Mikrofonfunktion

Anweisungen

Wir bearbeiten MicrophoneManager.cs , um die Diktiererkennung zu verwenden. Folgendes wird hinzugefügt:

1. Wenn die Schaltfläche Aufzeichnen gedrückt wird, starten wir den DictationRecognizer.
2. Zeigen Sie die Hypothese an, was der DictationRecognizer verstanden hat.
3. Sperren Sie die Ergebnisse des Verständnisses von DictationRecognizer.
4. Suchen Sie nach Timeouts aus dem DictationRecognizer.
5. Wenn die Stop-Taste gedrückt ist oder die Mikrofonsitzung ein Zeitüberschreitung aufweist, beenden Sie den DictationRecognizer.
6. Starten Sie den KeywordRecognizer neu, der auf den Befehl Nachricht senden lauscht.

Fangen wir also an. Führen Sie alle Codierungsübungen für 3.a in MicrophoneManager.cs aus, oder kopieren Sie den fertigen Code, den Sie unten finden:

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See LICENSE in the project root for license information.

using System.Collections;
using System.Text;
using UnityEngine;
using UnityEngine.UI;
using UnityEngine.Windows.Speech;

namespace Academy
{
    public class MicrophoneManager : MonoBehaviour
    {
        [Tooltip("A text area for the recognizer to display the recognized strings.")]
        [SerializeField]
        private Text dictationDisplay;

        private DictationRecognizer dictationRecognizer;

        // Use this string to cache the text currently displayed in the text box.
        private StringBuilder textSoFar;

        // Using an empty string specifies the default microphone.
        private static string deviceName = string.Empty;
        private int samplingRate;
        private const int messageLength = 10;

        // Use this to reset the UI once the Microphone is done recording after it was started.
        private bool hasRecordingStarted;

        void Awake()
        {
            /* TODO: DEVELOPER CODING EXERCISE 3.a */

            // 3.a: Create a new DictationRecognizer and assign it to dictationRecognizer variable.
            dictationRecognizer = new DictationRecognizer();

            // 3.a: Register for dictationRecognizer.DictationHypothesis and implement DictationHypothesis below
            // This event is fired while the user is talking. As the recognizer listens, it provides text of what it's heard so far.
            dictationRecognizer.DictationHypothesis += DictationRecognizer_DictationHypothesis;

            // 3.a: Register for dictationRecognizer.DictationResult and implement DictationResult below
            // This event is fired after the user pauses, typically at the end of a sentence. The full recognized string is returned here.
            dictationRecognizer.DictationResult += DictationRecognizer_DictationResult;

            // 3.a: Register for dictationRecognizer.DictationComplete and implement DictationComplete below
            // This event is fired when the recognizer stops, whether from Stop() being called, a timeout occurring, or some other error.
            dictationRecognizer.DictationComplete += DictationRecognizer_DictationComplete;

            // 3.a: Register for dictationRecognizer.DictationError and implement DictationError below
            // This event is fired when an error occurs.
            dictationRecognizer.DictationError += DictationRecognizer_DictationError;

            // Query the maximum frequency of the default microphone. Use 'unused' to ignore the minimum frequency.
            int unused;
            Microphone.GetDeviceCaps(deviceName, out unused, out samplingRate);

            // Use this string to cache the text currently displayed in the text box.
            textSoFar = new StringBuilder();

            // Use this to reset the UI once the Microphone is done recording after it was started.
            hasRecordingStarted = false;
        }

        void Update()
        {
            // 3.a: Add condition to check if dictationRecognizer.Status is Running
            if (hasRecordingStarted && !Microphone.IsRecording(deviceName) && dictationRecognizer.Status == SpeechSystemStatus.Running)
            {
                // Reset the flag now that we're cleaning up the UI.
                hasRecordingStarted = false;

                // This acts like pressing the Stop button and sends the message to the Communicator.
                // If the microphone stops as a result of timing out, make sure to manually stop the dictation recognizer.
                // Look at the StopRecording function.
                SendMessage("RecordStop");
            }
        }

        /// <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()
        {
            // 3.a Shutdown the PhraseRecognitionSystem. This controls the KeywordRecognizers
            PhraseRecognitionSystem.Shutdown();

            // 3.a: Start dictationRecognizer
            dictationRecognizer.Start();

            // 3.a Uncomment this line
            dictationDisplay.text = "Dictation is starting. It may take time to display your text the first time, but begin speaking now...";

            // Set the flag that we've started recording.
            hasRecordingStarted = true;

            // Start recording from the microphone for 10 seconds.
            return Microphone.Start(deviceName, false, messageLength, samplingRate);
        }

        /// <summary>
        /// Ends the recording session.
        /// </summary>
        public void StopRecording()
        {
            // 3.a: Check if dictationRecognizer.Status is Running and stop it if so
            if (dictationRecognizer.Status == SpeechSystemStatus.Running)
            {
                dictationRecognizer.Stop();
            }

            Microphone.End(deviceName);
        }

        /// <summary>
        /// This event is fired while the user is talking. As the recognizer listens, it provides text of what it's heard so far.
        /// </summary>
        /// <param name="text">The currently hypothesized recognition.</param>
        private void DictationRecognizer_DictationHypothesis(string text)
        {
            // 3.a: Set DictationDisplay text to be textSoFar and new hypothesized text
            // We don't want to append to textSoFar yet, because the hypothesis may have changed on the next event
            dictationDisplay.text = textSoFar.ToString() + " " + 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 when the recognizer stops, whether from Stop() being called, a timeout occurring, or some other error.
        /// Typically, this will simply return "Complete". In this case, we check to see if the recognizer timed out.
        /// </summary>
        /// <param name="cause">An enumerated reason for the session completing.</param>
        private void DictationRecognizer_DictationComplete(DictationCompletionCause cause)
        {
            // If Timeout occurs, the user has been silent for too long.
            // With dictation, the default timeout after a recognition is 20 seconds.
            // The default timeout with initial silence is 5 seconds.
            if (cause == DictationCompletionCause.TimeoutExceeded)
            {
                Microphone.End(deviceName);

                dictationDisplay.text = "Dictation has timed out. Please press the record button again.";
                SendMessage("ResetAfterTimeout");
            }
        }

        /// <summary>
        /// This event is fired when an error occurs.
        /// </summary>
        /// <param name="error">The string representation of the error reason.</param>
        /// <param name="hresult">The int representation of the hresult.</param>
        private void DictationRecognizer_DictationError(string error, int hresult)
        {
            // 3.a: Set DictationDisplay text to be the error string
            dictationDisplay.text = error + "\nHRESULT: " + hresult;
        }

        /// <summary>
        /// The dictation recognizer may not turn off immediately, so this call blocks on
        /// the recognizer reporting that it has actually stopped.
        /// </summary>
        public IEnumerator WaitForDictationToStop()
        {
            while (dictationRecognizer != null && dictationRecognizer.Status == SpeechSystemStatus.Running)
            {
                yield return null;
            }
        }
    }
}

Erstellen und Bereitstellen

• Erstellen Sie in Visual Studio neu, und stellen Sie sie auf Ihrem Gerät bereit.
• Schließen Sie das Fit-Feld mit einer Luft tippen-Geste.
• Blicken Sie auf die watch des Astronauten und sagen Sie "Open Communicator".
• Wählen Sie die Schaltfläche Aufzeichnen (Mikrofon) aus, um Ihre Nachricht aufzuzeichnen.
• Beginnen Sie zu sprechen. Die Diktiererkennung interpretiert Ihre Sprache und zeigt den hypothetischen Text im Kommunikator an.
• Versuchen Sie, "Nachricht senden" zu sagen, während Sie eine Nachricht aufzeichnen. Beachten Sie, dass die Schlüsselworterkennung nicht reagiert, da die Diktiererkennung weiterhin aktiv ist.
• Hören Sie einige Sekunden lang mit dem Sprechen auf. Sehen Sie sich an, wie die Diktiererkennung ihre Hypothese vervollständigt und das endgültige Ergebnis anzeigt.
• Beginnen Sie mit dem Sprechen, und halten Sie dann 20 Sekunden lang an. Dies führt zu einem Timeout für die Diktiererkennung .
• Beachten Sie, dass die Schlüsselworterkennung nach dem oben genannten Timeout wieder aktiviert ist. Der Kommunikator reagiert nun auf Sprachbefehle.
• Sagen Sie "Nachricht senden" , um die Nachricht an den Astronauten zu senden.

Kapitel 4: Grammatikerkennung

Ziele

• Verwenden Sie die Grammatikerkennung, um die Sprache des Benutzers gemäß einer SRGS- oder Spracherkennungsgrammatik-Datei zu erkennen.

Hinweis

Die Mikrofonfunktion muss deklariert werden, damit eine App vom Mikrofon aufzeichnen kann. Dies geschieht für Sie bereits in MR Input 212, aber beachten Sie dies für Ihre eigenen Projekte.

1. Navigieren Sie im Unity-Editor zu den Playereinstellungen, indem Sie zu "Projekteinstellungen-Player > bearbeiten>" navigieren.
2. Klicken Sie auf die Registerkarte "Universelle Windows-Plattform".
3. Überprüfen Sie im Abschnitt "Funktionen für Veröffentlichungseinstellungen>" die Mikrofonfunktion

Anweisungen

1. Suchen Sie im Hierarchiebereich nach Jetpack_Center , und wählen Sie sie aus.
2. Suchen Sie im Bereich "Inspektor" nach dem Skript "Tagalong-Aktion".
3. Klicken Sie auf den kleinen Kreis rechts neben dem Feld Objekt Zum Markieren entlang .
4. Suchen Sie im angezeigten Fenster nach SRGSToolbox , und wählen Sie es aus der Liste aus.
5. Sehen Sie sich die dateiSRGSColor.xml im Ordner StreamingAssets an .
   1. Die SRGS-Designspezifikation finden Sie hier auf der W3C-Website.

In unserer SRGS-Datei gibt es drei Arten von Regeln:

• Eine Regel, mit der Sie eine Farbe aus einer Liste mit zwölf Farben sagen können.
• Drei Regeln, die auf eine Kombination aus der Farbregel und einer der drei Formen lauschen.
• Die Stammregel colorChooser, die auf eine beliebige Kombination der drei Regeln "Color + Shape" lauscht. Die Formen können in beliebiger Reihenfolge und in beliebiger Menge von nur 1 bis alle drei angegeben werden. Dies ist die einzige Regel, auf die lauscht wird, da sie als Stammregel oben in der Datei im anfänglichen <Grammatiktag> angegeben wird.

Erstellen und Bereitstellen

• Erstellen Sie die Anwendung in Unity neu, und erstellen Sie sie dann in Visual Studio, und stellen Sie sie bereit, um die App in HoloLens zu erleben.
• Schließen Sie das Fit-Feld mit einer Luft tippen-Geste.
• Blicken Sie auf das Jetpack des Astronauten und führen Sie eine Luft-Tipp-Geste aus.
• Beginnen Sie zu sprechen. Die Grammatikerkennung interpretiert Ihre Sprache und ändert die Farben der Formen basierend auf der Erkennung. Ein Beispielbefehl ist "blauer Kreis, gelbes Quadrat".
• Führen Sie eine weitere Air tap-Geste aus, um die Toolbox zu schließen.

Das Ende

Herzlichen Glückwunsch! Sie haben jetzt MR Input 212: Voice abgeschlossen.

• Sie kennen die Dos und Don'ts der Sprachbefehle.
• Sie haben gesehen, wie QuickInfos verwendet wurden, um Benutzer auf Sprachbefehle aufmerksam zu machen.
• Sie haben verschiedene Arten von Feedback gesehen, die verwendet wurden, um zu bestätigen, dass die Stimme des Benutzers gehört wurde.
• Sie wissen, wie Sie zwischen der Schlüsselworterkennung und der Diktiererkennung wechseln und wie diese beiden Features Ihre Stimme verstehen und interpretieren.
• Sie haben gelernt, wie Sie eine SRGS-Datei und die Grammatikerkennung für die Spracherkennung in Ihrer Anwendung verwenden.