Tutoriel : Utilisation des API Speech du Framework .NET en VB avec Windows 7

  • Article

Partie 2 : La reconnaissance vocale

Téléchargez le tutorial et la source

Article par Eric Vernié Microsoft France Division Plate-forme & Ecosystème

Je rencontre les développeurs pour leur faire partager ma passion pour le développement autour des technologies .NET sans oublier le monde natif autour des Apis Win32.

J'ai également en charge la préparation de certains contenus pour des séminaires tel que les TechDays. Retrouvez moi sur les centres de développement Visual C++, Le Framework .NET, ainsi que le site sécurité.

Sommaire de l'article

  • Introduction
  • La reconnaissance vocale
  • Comprendre la grammaire du W3C
    • But de la grammaire
    • Exemple de grammaire
    • Interprétation sémentique (SI)
  • Prérequis
  • Tutoriel reconnaissance vocale
    • Exercice 1 : Création de la grammaire
    • Exercice 2 : Activation de la reconnaissance vocale
  • Conclusion

Introduction

Dans la première partie de notre tutoriel https://msdn.microsoft.com/fr-fr/vbasic/gg195176nous avons abordé la manière de synthétiser un texte. Dans cette seconde partie, nous verrons comment ajouter de la reconnaissance vocale à notre application, afin qu’elle réagisse, à des mots ou à des phrases.
Vous aurez noté dans cette première partie, que nous avons à notre disposition deux jeux d’API .NET (avec une nomenclature identique), pour effectuer le même travail. Nous les réutiliserons de la même manière dans cette seconde partie. Mais ce qu’il faut savoir, c’est que les moteurs de reconnaissance vocaux sont différents, celui de Windows demande un apprentissage, alors que celui d’UCMA ce n’est pas nécessaire.

La reconnaissance vocale

La reconnaissance vocale ou reconnaissance automatique de la parole (Automatic Speech Recognition ASR) est une technique informatique qui permet d'analyser un mot ou une phrase captée au moyen d'un microphone pour la transcrire sous la forme d'un texte exploitable par une machine. La reconnaissance vocale, ainsi que la synthèse vocale, l'identification du locuteur ou la vérification du locuteur, font partie des techniques de traitement de la parole. Ces techniques permettent notamment de réaliser des interfaces vocales c'est-à-dire des interfaces homme-machine (IHM) où une partie de l'interaction se fait à la voix. Parmi les nombreuses applications, on peut citer les applications de dictée vocale sur PC où la difficulté tient à la taille du vocabulaire et à la longueur des phrases, mais aussi les applications téléphoniques de type serveur vocal, où la difficulté tient plutôt à la nécessité de reconnaître n'importe quelle voix dans des conditions acoustiques variables et souvent bruyantes (téléphones mobiles dans des lieux publics). « Source Wikipedia »
Pour en savoir plus: http://fr.wikipedia.org/wiki/Reconnaissance_vocale

Alors comment sa marche ?
Pour que l'application, réponde correctement à une locution verbale (mot simple, ou phrase complexe) il faut alimenter le moteur de reconnaissance vocale avec une grammaire.
Cette grammaire, que nous aborderons un peu plus en détail par la suite peut être créée de 4 manières différentes. Directement par code, via les objets GrammarBuilder, ou SrgsGrammar, ou à partir de fichiers textes au format XML du standard W3C Speech Recognition Grammar Specification (SRGS), ou alors dans un format XML spécifique à SAPI.
Dans notre tutoriel, nous focaliserons, uniquement sur la grammaire au format SRGS.

01

Dans la première partie de notre tutoriel, nous avons vu comment synthétiser du texte, c’est-à-dire comment un texte écrit peut être lu par le PC. Dans cette seconde partie, nous allons ajouter des commandes simples vocales, afin que l'application y réagisse. Les commandes seront

  • Lecture d’un texte
  • Pause de la lecture d’un texte
  • Reprendre la lecture
  • Arrêter la lecture.
  • Quitter l’application

Pour ajouter ce type de fonctionnalité à l’application, il est possible d’utiliser les APIS .NET suivantes :

  • Soit les API du poste client System.Speech, fournit avec la plate-forme .NET 4.0, qui permet de piloter le moteur vocale de Windows 7
  • Soit les API serveur Microsoft.Speech, fournit avec le Kit de développement Unified Communications API (UCMA 3.0) qui permet de piloter le moteur vocale fournit avec Microsoft Lync, et qui tourne parfaitement sur un Client Windows 7.

Comprendre la grammaire du W3C

Pour bien appréhender la notion de reconnaissance vocale, il faut avant tout comprendre comment construire une grammaire, car l’utilisation des API .NET en elle-même comme vous le verrez par la suite est une formalité.
Une grammaire consiste en une liste structurée de règles (<rule>) qui identifient les mots ou expressions qui peuvent être utilisées pour la reconnaissance de la parole. Ces règles prévoient les lignes directrices qu'une application utilise lors de la collecte d'entrées parlées. Les lignes directrices servent à imiter ou à anticiper les entrées vocales des utilisateurs et à restreindre les mots ou expressions qui peuvent être reconnus par l'application.

Les règles de la grammaire se composent d'un ensemble prédéfini d'éléments XML (Extensible Markup Language) qui suivent les directives définies par le format du World Wide Web Consortium (W3C) Speech Recognition Grammar Specification Version 1.0. Les règles peuvent identifier des commandes définies par un mot simple, tels que « LECTURE », « ARRETER », « PAUSE », « REPRENDRE » etc, ou des phrases plus complexe tels que « ARRETER LA LECTURE DU TEXTE » ou « JE VOUDRAIS RESERVER UN VOL DE PARIS A TOULOUSE POUR VENDREDI PROCHAIN. »
Parce que les grammaires sont écrites en XML, un auteur peut utiliser n'importe quel éditeur XML (y compris les éditeurs de texte brut) pour les écrire. Les fichiers de grammaires peuvent être des fichiers XML ou compilés en fichiers binaires.

But de la grammaire

  • Les grammaires doivent seulement contenir les mots exacts ou phrases qu’une application à besoin de faire correspondre afin de reconnaitre correctement les entrées vocales de l’utilisateur. En fournissant explicitement des mots dans une grammaire, cela aide à la précision du moteur de reconnaissance vocale. Ce moteur est également moins susceptible de reconnaitre une commande absurde comme « crack zorglub » que la commande « ARRETER LA LECTURE DU TEXTE ». En d’autres termes une bonne grammaire, inclue des commandes courantes ou des phrases du langage naturel parlé.
  • Le moteur de reconnaissance vocale, analyse tous les signaux audio qu’il reçoit, indépendamment de ce qui est contenu dans la grammaire, puis fait correspondre les mots ou les phrases qui sont définies dans la grammaire. La grammaire aide à filtrer les entrées utilisateurs et permet au moteur de reconnaissance vocale de lever des évènements soit de reconnaissance réussi, soit de mots ou phrases rejetés car l’entrée n’est pas reconnue.
  • Bien que les grammaires doivent être souple et s’adapter à une multitude de phrases ou de phrasés, elles doivent également restreindre les entrées utilisateurs à une situation ou tâche particulière. Chaque application doit avoir son propre langage naturel. Un système de commande de cafés, doit se concentrer sur le vocabulaire de commandes de cafés, et non pas sur la commande de billets d’avions.
  • Les grammaires utilisent des règles <rule>, afin de définir et ordonner les mots que l’utilisateur peut soumettre, et une règle peut être composée de plusieurs règles. Une interface vocale pour une application, généralement contient une règle pour les menus, les éléments d’un menu, ou l’affichage d’une boite de dialogue accessible directement par une commande. La combinaison de ces règles forme une grammaire. Chaque règle possède un ID et lorsque la reconnaissance réussie, on pourra utiliser cet ID pour retrouver la commande exacte.
    Il est également possible de définir pour une règle un ensemble de phrases. Si l’utilisateur prononce, « LECTURE DU TEXTE », « SYNTHETISER LE TEXTE », « JOUER LE TEXTE » définies dans la grammaire, le moteur renverra l’ID ou le nom de la règle, que l’application pourra utiliser pour exécuter la commande. L’application n’aura donc pas à détecter tous les mots.
  • La grammaire est également en charge de fournir les bases d’une sémantique (Semantic Markup Language (SML). Cette sémantique  est retournée dans le résultat qui est envoyé à l’application afin que celle-ci puisse identifier et analyser le texte retourné. Une sortie SML est une sortie au format XML qui contient les éléments de la grammaire SML (c’est cette sémantique que devra analyser l’application afin de retrouver la bonne commande à exécuter). Les éléments de la grammaire SML peuvent avoir zéro, un, ou plusieurs enfants. Les expressions de scripts contenues dans l’élément <tag> généreront des valeurs de sémantique pour les éléments <item> et les règles référencées <ruleref/> contenues dans une règle parent.

Exemple de grammaire

Sans rentrer trop dans le détail du format XML d’une grammaire, en voici les éléments principaux : (Vous retrouverez dans la documentation MSDN tout le détail des éléments et des attributs utilisés https://msdn.microsoft.com/en-us/library/ff394896.aspx)

Une grammaire commence toujours par la balise <grammer>

<grammar xml:lang="fr-FR" root="root" tag-format="semantics/1.0"
         version="1.0" xmlns="http://www.w3.org/2001/06/grammar">

Ensuite il faut définir la règle racine

<rule id="root"scope="private">

Pour cette règle, vous pouvez définir des éléments simples

<one-of>
      <item>ARRETER</item>
      <item>PAUSE</item>
      <item>REPRENDRE</item>
</one-of>

Ou alors des éléments qui pointent sur une règle référencée

<item>
    <ruleref uri="#ID_LECTURE" />
</item>

  <ruleid="ID_LECTURE">
    <one-of>
      <item>Lecture du texte</item>
      <item>Lecture</item>
      <item>Synthétiser le texte</item>
      <item>Synthétiser</item>
      <item>Jouer le texte</item>
      <item>Jouer</item>
    </one-of>
  </rule>

A noter que la commande pour lire un texte, est associée à plusieurs mots ou phrases. Pour éviter que l’application, n’est à analyser l’ensemble des phrases, il lui faut dans notre exemple lui associer une sémantiqueparticulière via l’élément <tag>

<item>
        <ruleref uri="#ID_LECTURE" />
        <tag>out="LECTURE";</tag>
</item>

L’application n’aura plus qu’à identifier «LECTURE» comme mot clé pour exécuter la bonne commande.
Dans notre exemple, si l’utilisateur prononce par exemple la phrase « LECTURE DU TEXTE », le moteur de reconnaissance vocale retourne dans le résultat, la sortie SML suivante. :

<SML text="Lecture du texte" utteranceConfidence="0.917" confidence="0.917">
  LECTURE<alternate Rank="1" text="Lecture du texte" utteranceConfidence="0.917" confidence="0.917">LECTURE</alternate>

</SML>

Rassurez-vous, avec les classes .NET du moteur de reconnaissance vocale, nous manipulerons des objets et non pas du XML.

Il est également possible de combiner des éléments.

<item>ARRETER
      <ruleref uri="#ID_LECTURE"/>
        <tag>out="ARRETER";</tag>
</item>

Ici si l’utilisateur prononce ARRETER LECTURE DU TEXTE, la commande ARRETER sera identifiée et le SML retourné sera :

<SML text="ARRETER Lecture du texte" utteranceConfidence="0.775" confidence="0.775">
  ARRETER<alternate Rank="1" text="ARRETER Lecture du texte" utteranceConfidence="0.775" confidence="0.775">ARRETER</alternate>
</SML>

Interprétation sémantique (SI)

L’interprétation sémantique est le procédé par lequel le moteur de reconnaissance génère une valeur sémantique basé sur une expression (mot, phrases) correspondant à une grammaire. Le résultat sémantique typiquement contient des informations qui sont plus utiles que le texte lui-même de l’expression.
Dans notre exemple, lorsque l’utilisateur dira ARRETER LECTURE DU TEXTE, l’interpréteur sémantique retournera comme valeur ARRETER. Valeur plus utile et plus facile à manipuler dans l’application.

Le moteur de reconnaissance vocale de Microsoft, est basé sur les spécifications http://www.w3.org/TR/semantic-interpretation/. Dans cette spécification, il est à noter que l’élément <tag> peut être soit une chaine littérale soit du code ECMAScript http://www.ecma-international.org/publications/standards/Ecma-327.htm

Je cite "statements in Semantic Interpretation Tags are either valid ECMAScript code (Compact Profile) or string literals"

En d’autres termes, il est possible dans cet élément d’y placer du code du type JScript https://msdn.microsoft.com/en-us/library/6974wx4d(vs.71).aspx, et c’est ce que vous pouvez constater dans notre exemple <tag> out="ARRETER";</tag>

Pour des scénarios, plus complexes, sachez qu’il est possible d’instancier des objets dans l’élément tag
<tag>out.MonObjet=new Object();</tag>
Voir d’exécuter des fonctions JScript
<grammar xml:lang="fr-FR" root="root" tag-format="semantics/1.0"
         version="1.0" xmlns="http://www.w3.org/2001/06/grammar">
  <tag>
  <![CDATA[
    function GetName()
    {
      return "Eric Vernié";
    }
  ]]>
   </tag>

  <rule id="root" scope="private">
   
    <one-of>
            <item>
        qui est tu
        <tag>out=GetName();</tag>
      </item>

Lorsque l’utilisateur prononcera la phrase QUI EST TU, la fonction GetName() sera évaluée et retournera la chaine de caractères « Eric Vernié ».

Le SML généré est le suivant :
<SML text="qui est tu" utteranceConfidence="0.938" confidence="0.938">
  Eric Vernié<alternate Rank="1" text="qui est tu" utteranceConfidence="0.938" confidence="0.938">Eric Vernié</alternate>
</SML>

Pour des exemples plus détaillés, n’hésitez pas à visiter https://msdn.microsoft.com/en-us/library/ff394918.aspx,
Ou si vous installez le kit de développement Microsoft Speech Platform 10.2, vous retrouverez des exemples de grammaires utilisant JScript, à cet emplacement.
C:\Program Files\Microsoft Speech Platform SDK\Samples\Sample Grammars\

Prérequis

Pour réaliser les exemples de cet article il vous faut :

  • Si vous n'avez pas fait la 1ere partie du tutoriel, consacré à la synthèse vocale, je vous encourage à le faire et c'est ici

  • Visual Studio VB Express

  • Windows 7 en Français. Si vous avez une version Anglaise, il est facile d’installer le pack de langue Française à partir de Windows Update. Néanmoins seule la langue Française pour la reconnaissance vocale sera disponible, mais toujours pas de langue Française pour la synthèse vocale. Il vous faut alors acheter une voie Française sinon télécharger gratuitement la voie Virginie. (La voie Virginie est fournie avec le code source de cet article)

  • Si vous souhaitez utiliser également Microsoft.Speech vous devez télécharger et installer les composants suivants :

  • Microsoft Speech Platform Server SDK (10.2)

  • Microsoft Speech Platform Runtime Server (10.2)

  • Microsoft Speech Platform – Languages (10.2) en choisissant :

    • MSSpeech_SR_fr-FR_TELE.msi pour la reconnaissance vocale Française
    • MSSpeech_TTS_fr-FR_Hortense.msi pour la synthèse vocale Française

Tutoriel reconnaissance vocale

Comme je le disais en introduction, il existe deux jeux d’API permettant de faire de la synthèse vocale. Nous allons donc les utiliser, toutes les deux, mais attention, ce n’est pas une nécessité. Les deux API présentes une nomenclature identique, l'utilisation d'une constante de compilation nous permettra de commuter entre les deux.
Et avant de commencer les exercices, il est préférable de télécharger le projet de la Partie I à cette adresse https://msdn.microsoft.com/fr-fr/vbasic/gg195176

Exercice 1 : Création de la grammaire

Pour créer une grammaire il suffit de créer un fichier au format XML de la manière suivante :

  • Dans le projet SpeechVB, ajoutez un fichier XML que vous nommez Commandes.xml, comme indiqué sur la figure suivante :

    02

  • Dans ce fichier XML ajoutez le code suivant :
    <grammar xml:lang="fr-FR" root="root" tag-format="semantics/1.0"
             version="1.0" xmlns="http://www.w3.org/2001/06/grammar">
      <rule id="root" scope="private">
        <one-of>
          <item>ARRETER
          <ruleref uri="#ID_LECTURE"/>
            <tag>out="ARRETER";</tag>
          </item>
          <item>
            <ruleref uri="#ID_PAUSE"/>
            <tag>out="PAUSE";</tag>
          </item>
          <item>
            <ruleref uri="#ID_REPRENDRE"/>
            <tag>out="REPRENDRE";</tag>
           </item>
          <item>
            <ruleref uri="#ID_QUITTER" />
            <tag>out="QUITTER";</tag>
          </item>
          <item>
            <ruleref uri="#ID_LECTURE" />
            <tag>out="LECTURE";</tag>
          </item>
       </one-of>
      </rule>
      <rule id="ID_QUITTER" >
        <one-of>
          <item>Quitter l'application</item>
          <item>Fermer l'application</item>
          <item>Quitter</item>
          <item></item>
        </one-of>
      </rule>
      <rule id="ID_LECTURE">
        <one-of>
          <item>Lecture du texte</item>
          <item>Lecture</item>
          <item>Synthetiser le texte</item>
          <item>Synthetiser</item>
          <item>Jouer le texte</item>
          <item>Jouer</item>
        </one-of>
      </rule>
      <rule id="ID_PAUSE" >
          <item>PAUSE</item>
      </rule>
      <rule id="ID_REPRENDRE" >
        <item>REPRENDRE</item>
      </rule>
    </grammar>

    Note : Il est possible de créer une grammaire directement à partir du code.
    Exemple de création d’une grammaire simple par code.
    Private Function CreerGrammaire() As GrammarBuilder
    Dim GrammaireRoot As New GrammarBuilder
    Dim Grammaire As New GrammarBuilder
    Dim choixRoot As New Choices
    Dim choix As New Choices
    Dim phrases As String() = New String() {"lecture du texte", "Synthetiser le texte", "Lecture"}
    choix.Add(phrases)
    Dim GrammaireSemantic As New GrammarBuilder(choix)
    Dim value As New SemanticResultValue("LECTURE")
    Dim key As New SemanticResultKey("ID_LECTURE", New GrammarBuilder() {GrammaireSemantic})
    Grammaire.Append(key)
    Grammaire.Append(value)
    choixRoot.Add(New GrammarBuilder() {Grammaire})
    choix = New Choices(New String() {"PAUSE"})
    GrammaireSemantic = New GrammarBuilder(choix)
    value = New SemanticResultValue("PAUSE")
    key = New SemanticResultKey("ID_PAUSE", New GrammarBuilder() {GrammaireSemantic})
    Grammaire = New GrammarBuilder
    Grammaire.Append(key)
    Grammaire.Append(value)
    choixRoot.Add(New GrammarBuilder() {Grammaire})
    GrammaireRoot.Append(choixRoot)
    #If DEBUG Then
    Dim s As New SrgsDocument(GrammaireRoot)
    MainWindow.SauvegarderGrammaire(s, "grammaireAnnexe.grxml")
    #End If
    Return GrammaireRoot
    End Function

Exercice 2 : Activation de la reconnaissance vocale.

Maintenant que nous avons défini notre grammaire, nous allons activer la reconnaissance vocale, et utiliser notre grammaire.

  • Ouvrez le fichier MainWindow.xaml.cs, et dans l’entête ajoutez les imports propres à la reconnaissance vocale (en gras dans notre exemple):
    #If MICROSOFT_SPEECH Then
    Imports Microsoft.Speech
    Imports Microsoft.Speech.Synthesis
    Imports Microsoft.Speech.Recognition
    Imports Microsoft.Speech.Recognition.SrgsGrammar
    #Else
    Imports System.Speech
    Imports System.Speech.Synthesis
    Imports System.Speech.Recognition
    Imports System.Speech.Recognition.SrgsGrammar
    #End If

    Vous noterez ici, que nous utilisons une constante de compilation afin de basculer, sur l’une ou l’autre des APIS. Mais comme je le disais dans la partie I consacrée à la synthèse vocale, ce n’est pas une obligation d’installer Microsoft.Speech (UCMA 3.0) car la voix Française pour la reconnaissance vocale est disponible par défaut dans Windows 7. L’api System.Speech, peut faire donc largement l’affaire. Néanmoins comme la nomenclature est la même, apprendre l’une, c’est apprendre l’autre.

  • Dans la classe MainWindow ajoutez-y la déclaration suivante :
    Dim asr As SpeechRecognitionEngine

  • Dans le constructeur New, ajoutez-y le code suivant :
    Me.asr = New SpeechRecognitionEngine
    Me.asr.SetInputToDefaultAudioDevice()
    AddHandler Me.asr.SpeechRecognized, New EventHandler(Of SpeechRecognizedEventArgs)(AddressOf Me.asr_SpeechRecognized)
    AddHandler Me.asr.LoadGrammarCompleted, New EventHandler(Of LoadGrammarCompletedEventArgs)(AddressOf Me.asr_LoadGrammarCompleted)
    Me.asr.LoadGrammarAsync(New Grammar("Commandes.xml"))
    Me.asr.RecognizeAsync(RecognizeMode.Multiple)

    Le moteur de reconnaissance vocale est implémenté dans la classe SpeechRecognitionEngine, que nous instancions.
    Nous définissons que les entrées se feront via le périphérique audio par défaut SetInputToDefaultAudioDevice, à priori donc un microphone.
    Ensuite nous nous abonnons à l’évènement SpeechRecognized en lui passant comme paramètre la méthode asr_SpeechRecognized. C’est dans cette dernière méthode que nous récupèrerons le résultat de la reconnaissance vocale, comme nous le verrons par la suite.
    Puis nous chargeons la grammaire LoadGrammarAsync(), que nous avons créée à l’exercice 1. A noter qu’il est possible de charger plusieurs grammaires, et de les identifier via leur nom.
    Enfin, nous chargeons le moteur de reconnaissance vocale en mode asynchrone, qui se met en attente d’une entrée utilisateur.

  • Ajoutez la méthode suivante :
    Private Sub asr_LoadGrammarCompleted(ByVal sender As Object, ByVal e As LoadGrammarCompletedEventArgs)
    If (Not e.Error Is Nothing) Then
    MessageBox.Show(e.Error.Message)
    End If
    End Sub
    Cette méthode nous permet de vérifier simplement, qu’il n’y a pas d’erreur dans la grammaire. Elle est appelée lorsque la grammaire à finie d’être chargée par la méthode LoadGrammaireAsync

  • Enfin, nous allons définir la méthode asr_SpeechRecognized qui nous permettra de récupérer le ou les résultats de la reconnaissance vocale.
    Pour ce faire ajoutez le code suivant :
    Private Sub asr_SpeechRecognized(ByVal sender As Object, ByVal e As SpeechRecognizedEventArgs)
    MessageBox.Show(e.Result.Semantics.Value.ToString())
    End Sub
    Pour l’instant nous n’affichons que le résultat de la reconnaissance vocale. Vous aurez noté que la valeur de notre résultat pour notre grammaire (très simple) se retrouve dans l’objet nommé Semantics. Rappelez-vous en effet, que lorsque vous direz la phrase, LECTURE DU TEXTE ou SYNTHETISER LE TEXTE, ou JOUER LE TEXTE (contenue dans notre grammaire), l’interpréteur sémantique analyse la grammaire, et associera à cette phrase la valeur LECTURE.
    Lorsque vous direz ARRETER LECTURE DU TEXTE, l’interpréteur associera à l’objet Semantics, la valeur ARRETER et ainsi de suite avec les autres phrases contenues dans la grammaire.
    Note : Pour créer un fichier au format SML, à partir du résultat, il est possible d’utiliser la méthode ConstructSmlFromSemantics(), de la manière suivante :
    Dim path As IXPathNavigable = e.Result.ConstructSmlFromSemantics()
    Dim navigator As XPathNavigator
    navigator = path.CreateNavigator()
    Dim sml As String = navigator.InnerXml

  • Avant d’exécuter l’exemple, il faut configurer un microphone, pour la reconnaissance vocale.

    • Activez le panneau de configuration, puis dans la zone de recherche tapez « reconnaissance » comme sur la figure suivante :

      03

    • Dans l’assistant de configuration, choisissez votre type de microphone, puis continuez l’assistant jusqu’au bout.

      04

  • Compilez l’application, et exécutez là. Si vous avez utilisé le projet de la partie I, la fenêtre suivante doit apparaitre :

    05

  • Dans le microphone, dites la phrase ou les phrases LECTURE DU TEXTE, SYNTHETISER UN TEXTE etc.. la boite de message suivante doit s’afficher.

    06

  • Recommencez l’opération avec d’autres phrases.

Maintenant que nous avons les bases, nous allons pour finir implémenter, la synthèse vocale.

  • Ajoutez la déclaration suivante dans la classe MainWindow.
    Dim synth As SpeechSynthesizer

  • Dans le constructeur, ajoutez l’instanciation du synthètiseur
    synth = New SpeechSynthesizer()

  • Ajoutez la méthode suivante :
    Private Sub SynthetiserAsync()
    Dim builder As New PromptBuilder(New CultureInfo("fr-fr"))
    AddHandler Me.synth.SpeakCompleted, New EventHandler(Of  SpeakCompletedEventArgs)(AddressOf Me.s_SpeakCompleted)
    If (txtASynthetiser.Text = String.Empty) Then
    builder.AppendText("Vous devez entrer un texte à synthetiser")
    Else
    builder.AppendText(Me.txtASynthetiser.Text)
    End If

    Me.ConfigureSoundPlayer(Me.synth)
    Me.synth.SpeakAsync(builder)
    End Sub

    Note : Je ne reviens pas sur l’explication de la synthèse vocale, vous la retrouverez dans la partie I de ce tutorial. https://msdn.microsoft.com/fr-fr/vbasic/gg195176

  • Dans la méthode **asr_SpeechRecognized()**remplacez le code existant par ce code :
    Dim value As String = e.Result.Semantics.Value.ToString
    Select Case value
    Case "ARRETER"
    Me.synth.SpeakAsyncCancelAll()
    Case "PAUSE"
    Me.synth.Pause()
    Case "LECTURE"
    Me.SynthetiserAsync()
    Case "REPRENDRE"
    Me.synth.Resume()
    Case "QUITTER"
    Me.Close()
    End Select

  • A vous de jouer !!!, lancez l’application, tapez un texte dans la zone de texte prévue à cette effet.

    07

    Dites la phrases LECTURE FICHIER TEXTE, le texte « Bonjour et bienvenue dans cette démonstration consacrée à la reconnaissance vocale » doit se synthétiser

 

Conclusion

Comme nous venons de le voir, l'utilisation des API Speech pour de la reconnaissance vocale reste somme toute assez simple à partir du moment où vous avez bien assimilé la notion de grammaire. Dans ce tutoriel, nous n’avons fait qu’aborder les bases, reste à vous d’approfondir afin d’enrichir votre application.
Mais il y a fort à parier que dans un avenir proche, la reconnaissance vocale, deviendra un élément essentiel de toute interface utilisateur, au même titre que le multitouche, ou la reconnaissance de gestes, comme avec la Kinect.