Partager via

Entrée vocale dans Unity

  • Article

Attention

Avant de commencer, envisagez d’utiliser le plug-in Unity pour le Kit de développement logiciel (SDK) Cognitive Speech Services. Le plug-in offre de meilleurs résultats de précision vocale et un accès facile au décodage de reconnaissance vocale, ainsi que des fonctionnalités vocales avancées telles que la boîte de dialogue, l’interaction basée sur l’intention, la traduction, la synthèse vocale en synthèse vocale et la reconnaissance vocale en langage naturel. Pour commencer, consultez l’exemple et la documentation.

Unity expose trois façons d’ajouter une entrée vocale à votre application Unity, dont les deux premières sont des types de PhraseRecognizer :

  • Fournit KeywordRecognizer à votre application un tableau de commandes de chaîne à écouter
  • Donne GrammarRecognizer à votre application un fichier SRGS définissant une grammaire spécifique à écouter
  • Permet DictationRecognizer à votre application d’écouter n’importe quel mot et de fournir à l’utilisateur une note ou un autre affichage de son discours

Remarque

La dictée et la reconnaissance d’expressions ne peuvent pas être gérées en même temps. Si un GrammarRecognizer ou KeywordRecognizer est actif, un DictationRecognizer ne peut pas être actif et vice versa.

Activation de la fonctionnalité pour Voice

La fonctionnalité microphone doit être déclarée pour qu’une application utilise l’entrée vocale.

  1. Dans l’Éditeur Unity, accédez à Modifier le > lecteur paramètres > du projet
  2. Sélectionnez l’onglet Windows Store
  3. Dans la section Fonctionnalités des paramètres > de publication, consultez la fonctionnalité Microphone
  4. Accorder des autorisations à l’application pour l’accès au microphone sur votre appareil HoloLens
    • Vous serez invité à le faire au démarrage de l’appareil, mais si vous avez cliqué accidentellement sur « Non », vous pouvez modifier les autorisations dans les paramètres de l’appareil.

Reconnaissance d’expressions

Pour permettre à votre application d’écouter des expressions spécifiques parlées par l’utilisateur, vous devez effectuer une action :

  1. Spécifier les expressions à écouter à l’aide d’un KeywordRecognizer ou GrammarRecognizer
  2. Gérer l’événement OnPhraseRecognized et prendre des mesures correspondant à l’expression reconnue

KeywordRecognizer

Espace de noms : UnityEngine.Windows.Speech
Types : KeywordRecognizer, PhraseRecognizedEventArgs, SpeechError, SpeechSystemStatus

Nous aurons besoin de quelques instructions using pour enregistrer certaines séquences de touches :

using UnityEngine.Windows.Speech;
using System.Collections.Generic;
using System.Linq;

Nous allons ensuite ajouter quelques champs à votre classe pour stocker le dictionnaire de reconnaissance et de mot clé-action> :

KeywordRecognizer keywordRecognizer;
Dictionary<string, System.Action> keywords = new Dictionary<string, System.Action>();

Ajoutez maintenant un mot clé au dictionnaire, par exemple dans une Start() méthode. Nous ajoutons le mot clé « activate » dans cet exemple :

//Create keywords for keyword recognizer
keywords.Add("activate", () =>
{
    // action to be performed when this keyword is spoken
});

Créez le module de reconnaissance de mot clé et indiquez-lui ce que nous voulons reconnaître :

keywordRecognizer = new KeywordRecognizer(keywords.Keys.ToArray());

Inscrivez-vous maintenant à l’événement OnPhraseRecognized

keywordRecognizer.OnPhraseRecognized += KeywordRecognizer_OnPhraseRecognized;

Voici un exemple de gestionnaire :

private void KeywordRecognizer_OnPhraseRecognized(PhraseRecognizedEventArgs args)
{
    System.Action keywordAction;
    // if the keyword recognized is in our dictionary, call that Action.
    if (keywords.TryGetValue(args.text, out keywordAction))
    {
        keywordAction.Invoke();
    }
}

Enfin, commencez à reconnaître !

keywordRecognizer.Start();

GrammarRecognizer

Espace de noms : UnityEngine.Windows.Speech
Types : GrammarRecognizer, PhraseRecognizedEventArgs, SpeechError, SpeechSystemStatus

GrammarRecognizer est utilisé si vous spécifiez votre grammaire de reconnaissance à l’aide de SRGS. Cela peut être utile si votre application comporte plus que quelques mots clés, si vous souhaitez reconnaître des expressions plus complexes ou si vous souhaitez facilement activer et désactiver des ensembles de commandes. Voir : Créer des grammaires à l’aide de SRGS XML pour obtenir des informations de format de fichier.

Une fois que vous avez votre grammaire SRGS et qu’elle se trouve dans votre projet dans un dossier StreamingAssets :

<PROJECT_ROOT>/Assets/StreamingAssets/SRGS/myGrammar.xml

Créez un GrammarRecognizer fichier SRGS et transmettez-le le chemin d’accès à votre fichier SRGS :

private GrammarRecognizer grammarRecognizer;
grammarRecognizer = new GrammarRecognizer(Application.streamingDataPath + "/SRGS/myGrammar.xml");

Inscrivez-vous maintenant à l’événement OnPhraseRecognized

grammarRecognizer.OnPhraseRecognized += grammarRecognizer_OnPhraseRecognized;

Vous obtiendrez un rappel contenant des informations spécifiées dans votre grammaire SRGS, que vous pouvez gérer de manière appropriée. La plupart des informations importantes seront fournies dans le semanticMeanings tableau.

private void Grammar_OnPhraseRecognized(PhraseRecognizedEventArgs args)
{
    SemanticMeaning[] meanings = args.semanticMeanings;
    // do something
}

Enfin, commencez à reconnaître !

grammarRecognizer.Start();

Dictation

Espace de noms : UnityEngine.Windows.Speech
Types : DictationRecognizer, SpeechError, SpeechSystemStatus

Utilisez la DictationRecognizer fonction pour convertir la parole de l’utilisateur en texte. DictationRecognizer expose la fonctionnalité de dictée et prend en charge l’inscription et l’écoute des événements d’hypothèse et d’expression terminés. Vous pouvez donc envoyer des commentaires à votre utilisateur tant pendant qu’il parle et par la suite. Start() et Stop() les méthodes activent et désactivent respectivement la reconnaissance de dictée. Une fois le module de reconnaissance terminé, il doit être supprimé à l’aide Dispose() de la mise en production des ressources qu’il utilise. Elle libère ces ressources automatiquement pendant le garbage collection à un coût de performances supplémentaire s’ils ne sont pas libérés avant cela.

Il n’y a que quelques étapes nécessaires pour commencer à dicter :

  1. Créer un nouveau DictationRecognizer
  2. Gérer les événements de dictée
  3. Démarrer le DictationRecognizer

Activation de la fonctionnalité de dictée

Les fonctionnalités client et microphone Internet doivent être déclarées pour qu’une application utilise la dictée :

  1. Dans l’Éditeur Unity, accédez à Modifier > le lecteur paramètres > du projet
  2. Sélectionner sous l’onglet Windows Store
  3. Dans la section Fonctionnalités des paramètres > de publication, consultez la fonctionnalité InternetClient
    • Si vous n’avez pas déjà activé le microphone, vérifiez la fonctionnalité Microphone .
  4. Accordez des autorisations à l’application pour l’accès au microphone sur votre appareil HoloLens si vous ne l’avez pas déjà fait
    • Vous serez invité à le faire au démarrage de l’appareil, mais si vous avez cliqué accidentellement sur « Non », vous pouvez modifier les autorisations dans les paramètres de l’appareil.

DictationRecognizer

Créez un DictationRecognizer comme suit :

dictationRecognizer = new DictationRecognizer();

Il existe quatre événements de dictée qui peuvent être abonnés et gérés pour implémenter le comportement de dictée.

  1. DictationResult
  2. DictationComplete
  3. DictationHypothesis
  4. DictationError

DictationResult

Cet événement est déclenché après la pause de l’utilisateur, généralement à la fin d’une phrase. La chaîne reconnue complète est retournée ici.

Tout d’abord, abonnez-vous à l’événement DictationResult :

dictationRecognizer.DictationResult += DictationRecognizer_DictationResult;

Gérez ensuite le rappel DictationResult :

private void DictationRecognizer_DictationResult(string text, ConfidenceLevel confidence)
{
    // do something
}

DictationHypothèse

Cet événement est déclenché en continu pendant que l’utilisateur parle. À mesure que le module de reconnaissance écoute, il fournit du texte de ce qu’il entend jusqu’à présent.

Tout d’abord, abonnez-vous à l’événement DictationHypothesis :

dictationRecognizer.DictationHypothesis += DictationRecognizer_DictationHypothesis;

Gérez ensuite le rappel DictationHypothèse :

private void DictationRecognizer_DictationHypothesis(string text)
{
    // do something
}

DictationComplete

Cet événement est déclenché lorsque le module de reconnaissance s’arrête, qu’il s’agisse de Stop() appelé, d’un délai d’expiration ou d’une autre erreur.

Tout d’abord, abonnez-vous à l’événement DictationComplete :

dictationRecognizer.DictationComplete += DictationRecognizer_DictationComplete;

Gérez ensuite le rappel DictationComplete :

private void DictationRecognizer_DictationComplete(DictationCompletionCause cause)
{
   // do something
}

DictationError

Cet événement est déclenché lorsqu’une erreur se produit.

Tout d’abord, abonnez-vous à l’événement DictationError :

dictationRecognizer.DictationError += DictationRecognizer_DictationError;

Gérez ensuite le rappel DictationError :

private void DictationRecognizer_DictationError(string error, int hresult)
{
    // do something
}

Une fois que vous avez souscrit et géré les événements de dictée dont vous vous souciez, démarrez le module de reconnaissance de dictée pour commencer à recevoir des événements.

dictationRecognizer.Start();

Si vous ne souhaitez plus conserver le DictationRecognizer, vous devez vous désabonner des événements et supprimer le DictationRecognizer.

dictationRecognizer.DictationResult -= DictationRecognizer_DictationResult;
dictationRecognizer.DictationComplete -= DictationRecognizer_DictationComplete ;
dictationRecognizer.DictationHypothesis -= DictationRecognizer_DictationHypothesis ;
dictationRecognizer.DictationError -= DictationRecognizer_DictationError ;
dictationRecognizer.Dispose();

Conseils

  • Start() et Stop() les méthodes activent et désactivent respectivement la reconnaissance de dictée.
  • Une fois le module de reconnaissance terminé, il doit être supprimé à l’aide Dispose() de la mise en production des ressources qu’il utilise. Elle libère ces ressources automatiquement pendant le garbage collection à un coût de performances supplémentaire s’ils ne sont pas libérés avant cela.
  • Les délais d’expiration se produisent après une période définie. Vous pouvez rechercher ces délais d’expiration dans l’événement DictationComplete . Il existe deux délais d’expiration à prendre en compte :
    1. Si le module de reconnaissance démarre et n’entend pas d’audio pendant les cinq premières secondes, il expire.
    2. Si le module de reconnaissance a donné un résultat, mais entend le silence pendant 20 secondes, il expire.

Utilisation de la reconnaissance d’expressions et de la dictée

Si vous souhaitez utiliser à la fois la reconnaissance d’expressions et la dictée dans votre application, vous devez en arrêter complètement un avant de pouvoir démarrer l’autre. Si vous avez plusieurs KeywordRecognizers en cours d’exécution, vous pouvez les arrêter en même temps avec :

PhraseRecognitionSystem.Shutdown();

Vous pouvez appeler Restart() pour restaurer tous les modules de reconnaissance à leur état précédent après l’arrêt de DictationRecognizer :

PhraseRecognitionSystem.Restart();

Vous pouvez également démarrer un KeywordRecognizer, qui redémarrera également PhraseRecognitionSystem.

Entrée vocale dans Mixed Reality Toolkit

Vous trouverez des exemples MRTK pour l’entrée vocale dans les scènes de démonstration suivantes :

Point de contrôle de développement suivant

Si vous suivez le parcours de point de contrôle de développement Unity que nous avons mis en place, vous allez explorer les fonctionnalités et LES API de plateforme de réalité mixte :

Expériences partagées

Vous pouvez revenir aux points de contrôle de développement Unity à tout moment.