HoloLens (prima generazione) e Azure 301: traduzione della lingua

Nota

Le esercitazioni di Mixed Reality Academy sono state progettate in base a HoloLens (prima generazione) e ai visori VR immersive di realtà mista. Pertanto, riteniamo importante lasciarle a disposizione degli sviluppatori a cui serve ancora materiale sussidiario per lo sviluppo di questi dispositivi. Queste esercitazioni non verranno aggiornate con i set di strumenti o le interazioni più recenti usati per HoloLens 2. Rimarranno invariate per consentire di continuare a lavorare sui dispositivi supportati. Ci sarà una nuova serie di esercitazioni che verranno pubblicate in futuro che dimostreranno come sviluppare per HoloLens 2. Questo avviso verrà aggiornato con un collegamento a tali esercitazioni quando vengono pubblicate.

In questo corso si apprenderà come aggiungere funzionalità di traduzione a un'applicazione di realtà mista usando Servizi cognitivi di Azure, con l'API Traduzione testuale.

L'API Traduzione testuale è un servizio di traduzione che funziona quasi in tempo reale. Il servizio è basato sul cloud e, usando una chiamata API REST, un'app può usare la tecnologia di traduzione automatica neurale per tradurre il testo in un'altra lingua. Per altre informazioni, visitare la pagina dell'API Traduzione testuale di Azure.

Al termine di questo corso, si avrà un'applicazione di realtà mista che sarà in grado di eseguire le operazioni seguenti:

1. L'utente parlerà in un microfono connesso a un visore VR immersive (o al microfono incorporato di HoloLens).
2. L'app acquisirà la dettatura e la invierà all'API Traduzione testuale di Azure.
3. Il risultato della traduzione verrà visualizzato in un semplice gruppo di interfaccia utente nella scena unity.

Questo corso illustra come ottenere i risultati dal servizio Traduttore in un'applicazione di esempio basata su Unity. Sarà necessario applicare questi concetti a un'applicazione personalizzata che si sta creando.

Supporto di dispositivi

Corso	HoloLens	Visori VR immersive
MR e Azure 301: traduzione della lingua	✔️	✔️

Nota

Anche se questo corso è incentrato principalmente sui visori VR immersive di Windows Realtà mista, puoi anche applicare ciò che impari in questo corso a Microsoft HoloLens. Mentre segui il corso, vedrai le note su eventuali modifiche che potresti dover usare per supportare HoloLens. Quando si usa HoloLens, è possibile notare un'eco durante l'acquisizione vocale.

Prerequisiti

Nota

Questa esercitazione è progettata per gli sviluppatori che hanno esperienza di base con Unity e C#. Tenere presente anche che i prerequisiti e le istruzioni scritte all'interno di questo documento rappresentano ciò che è stato testato e verificato al momento della scrittura (maggio 2018). Sei libero di usare il software più recente, come elencato all'interno dell'articolo installare gli strumenti , anche se non si deve presumere che le informazioni in questo corso corrispondano perfettamente a ciò che troverai nel software più recente rispetto a quello elencato di seguito.

Per questo corso è consigliabile usare l'hardware e il software seguenti:

• Un PC di sviluppo, compatibile con Windows Realtà mista per lo sviluppo di visori VR immersive
• Windows 10 Fall Creators Update (o versione successiva) con la modalità sviluppatore abilitata
• La versione più recente di Windows 10 SDK
• Unity 2017.4
• Visual Studio 2017
• Visore VR immersive di Windows Realtà mista o Microsoft HoloLens con la modalità sviluppatore abilitata
• Un set di cuffie con un microfono incorporato (se l'auricolare non ha un microfono e altoparlanti incorporati)
• Accesso a Internet per il recupero della configurazione e della traduzione di Azure

Prima di iniziare

• Per evitare di riscontrare problemi durante la compilazione di questo progetto, è consigliabile creare il progetto menzionato in questa esercitazione in una cartella radice o quasi radice (i percorsi delle cartelle lunghe possono causare problemi in fase di compilazione).

• Il codice in questa esercitazione consentirà di registrare dal dispositivo microfono predefinito connesso al PC. Assicurarsi che il dispositivo microfono predefinito sia impostato sul dispositivo che si prevede di usare per acquisire la voce.

• Per consentire al PC di abilitare la dettatura, passare a Impostazioni > Privacy > Voce, input penna e digitazione e selezionare il pulsante Attiva servizi vocali e suggerimenti di digitazione.

• Se usi un microfono e le cuffie connesse (o predefinite) al visore VR, assicurati che l'opzione "Quando indosso il visore vr, passa al microfono del visore vr" sia attivata in Impostazioni Realtà > mista > Audio e riconoscimento vocale.

  

  

Avviso

Tieni presente che se stai sviluppando per un visore VR immersivo per questo lab, potresti riscontrare problemi con il dispositivo di output audio. Questo problema è dovuto a un problema con Unity, risolto nelle versioni successive di Unity (Unity 2018.2). Il problema impedisce a Unity di modificare il dispositivo di output audio predefinito in fase di esecuzione. Come soluzione alternativa, assicurarsi di aver completato i passaggi precedenti e chiudere e riaprire l'Editor, quando questo problema si presenta.

Capitolo 1: Portale di Azure

Per usare l'API Di Azure Translator, è necessario configurare un'istanza del servizio da rendere disponibile per l'applicazione.

1. Accedere al portale di Azure.

   Nota

   Se non si ha già un account Azure, è necessario crearne uno. Se si segue questa esercitazione in una classe o in una situazione di laboratorio, chiedere all'insegnante o a uno dei prottori di assistenza per configurare il nuovo account.

2. Dopo aver eseguito l'accesso, fare clic su Nuovo nell'angolo superiore sinistro e cercare "API Traduzione testuale". Selezionare INVIO.

   

   Nota

   La parola New potrebbe essere stata sostituita con Crea una risorsa, nei portali più recenti.

3. La nuova pagina fornirà una descrizione del servizio API Traduzione testuale. Nella parte inferiore sinistra di questa pagina selezionare il pulsante Crea per creare un'associazione con questo servizio.

   

4. Dopo aver fatto clic su Crea:

   1. Inserire il nome desiderato per questa istanza del servizio.

   2. Selezionare una sottoscrizione appropriata.

   3. Selezionare il piano tariffario appropriato, se questa è la prima volta che si crea un servizio traduzione testuale, sarà disponibile un livello gratuito (denominato F0).

   4. Scegliere un gruppo di risorse o crearne uno nuovo. Un gruppo di risorse consente di monitorare, controllare l'accesso, effettuare il provisioning e gestire la fatturazione per una raccolta di asset di Azure. È consigliabile mantenere tutti i servizi di Azure associati a un singolo progetto (ad esempio, questi lab) in un gruppo di risorse comune.

      Per altre informazioni sui gruppi di risorse di Azure, vedere l'articolo relativo al gruppo di risorse.

   5. Determinare la località per il gruppo di risorse (se si sta creando un nuovo gruppo di risorse). La posizione si trova idealmente nell'area in cui verrà eseguita l'applicazione. Alcuni asset di Azure sono disponibili solo in determinate aree.

   6. Sarà anche necessario verificare di aver compreso le condizioni e le condizioni applicate al servizio.

   7. Seleziona Crea.

      

5. Dopo aver fatto clic su Crea, è necessario attendere che il servizio venga creato, l'operazione potrebbe richiedere un minuto.

6. Una notifica verrà visualizzata nel portale dopo la creazione dell'istanza del servizio.

   

7. Fare clic sulla notifica per esplorare la nuova istanza del servizio.

   

8. Fare clic sul pulsante Vai alla risorsa nella notifica per esplorare la nuova istanza del servizio. Verrà visualizzata la nuova istanza del servizio API Traduzione testuale.

   

9. In questa esercitazione, l'applicazione dovrà effettuare chiamate al servizio, che viene eseguita usando la chiave di sottoscrizione del servizio.

10. Nella pagina Avvio rapido del servizio traduzione testuale passare al primo passaggio, Afferrare le chiavi e fare clic su Chiavi . È anche possibile fare clic sul collegamento ipertestuale blu Chiavi, che si trova nel menu di spostamento Servizi, indicato dall'icona della chiave. Verranno visualizzate le chiavi del servizio.

11. Prendere una copia di una delle chiavi visualizzate, perché sarà necessario più avanti nel progetto.

Capitolo 2: Configurare il progetto Unity

Configurare e testare il visore VR immersive di realtà mista.

Nota

Non avrai bisogno di controller di movimento per questo corso. Se è necessario supportare la configurazione di un visore VR immersive, seguire questa procedura.

Di seguito è riportata una configurazione tipica per lo sviluppo con la realtà mista e, di conseguenza, è un modello valido per altri progetti:

1. Aprire Unity e fare clic su Nuovo.

   

2. Sarà ora necessario specificare un nome di progetto Unity. Inserisci MR_Translation. Assicurarsi che il tipo di progetto sia impostato su 3D. Impostare La posizione su un punto appropriato per l'utente (tenere presente che più vicino alle directory radice è preferibile). Fare quindi clic su Crea progetto.

   

3. Con Unity aperto, vale la pena verificare che l'editor di script predefinito sia impostato su Visual Studio. Passare a Modifica > preferenze e quindi dalla nuova finestra passare a Strumenti esterni. Modificare l'editor di script esterni in Visual Studio 2017. Chiudere la finestra Preferenze .

   

4. Passare quindi a Impostazioni compilazione file > e impostare la piattaforma su piattaforma UWP (Universal Windows Platform), facendo clic sul pulsante Cambia piattaforma.

   

5. Passare a Impostazioni di compilazione file > e assicurarsi che:

   1. Il dispositivo di destinazione è impostato su Qualsiasi dispositivo.

      Per Microsoft HoloLens impostare Dispositivo di destinazione su HoloLens.

   2. Il tipo di compilazione è impostato su D3D

   3. L'SDK è impostato su Latest installed (Versione più recente installata)

   4. La versione di Visual Studio è impostata su Versione più recente installata

   5. Compilazione ed esecuzione è impostata su Computer locale

   6. Salvare la scena e aggiungerla alla compilazione.

      1. A tale scopo, selezionare Aggiungi scene aperte. Verrà visualizzata una finestra di salvataggio.

         

      2. Creare una nuova cartella per questa cartella e qualsiasi scena futura, quindi selezionare il pulsante Nuova cartella per creare una nuova cartella, denominarla Scene.

         

      3. Aprire la cartella Scenes appena creata e quindi nel campo Nome file: digitare MR_TranslationScene, quindi premere Salva.

         

         Tenere presente che è necessario salvare le scene di Unity all'interno della cartella Assets , perché devono essere associate al progetto Unity. La creazione della cartella scene (e altre cartelle simili) è un modo tipico di strutturare un progetto Unity.

   7. Le impostazioni rimanenti, in Impostazioni di compilazione, devono essere lasciate come predefinite per il momento.

6. Nella finestra Impostazioni di compilazione fare clic sul pulsante Impostazioni lettore per aprire il pannello correlato nello spazio in cui si trova il controllo.

   

7. In questo pannello è necessario verificare alcune impostazioni:

   1. Nella scheda Altre impostazioni :

      1. La versione del runtime di scripting deve essere stabile (equivalente a .NET 3.5).

      2. Il back-end di scripting deve essere .NET

      3. Il livello di compatibilità api deve essere .NET 4.6

         

   2. Nella scheda Impostazioni di pubblicazione, in Funzionalità selezionare:

      1. InternetClient

      2. Microfono

         

   3. Più avanti nel pannello, in Impostazioni XR (disponibili sotto Impostazioni di pubblicazione), selezionare Realtà virtuale supportata, assicurarsi che Windows Realtà mista SDK sia stato aggiunto.

      

8. Tornare in Impostazioni di compilazione, i progetti C# di Unity non sono più disattivati. Selezionare la casella di controllo accanto a questa.

9. Chiudere la finestra Build Settings (Impostazioni di compilazione).

10. Salvare la scena e il progetto (FILE > SAVE SCENE/FILE > SAVE PROJECT).

Capitolo 3 - Configurazione della fotocamera principale

Importante

Se si vuole ignorare il componente Di configurazione di Unity di questo corso e continuare direttamente nel codice, è possibile scaricare questo pacchetto unitypackage, importarlo nel progetto come pacchetto personalizzato e quindi continuare dal capitolo 5. Sarà comunque necessario creare un progetto Unity.

1. Nel pannello Hierarchy (Gerarchia) troverai un oggetto denominato Main Camera, questo oggetto rappresenta il punto di vista "head" quando sei "all'interno" dell'applicazione.

2. Con il dashboard unity davanti a te, seleziona il GameObject principale della fotocamera. Si noterà che il Pannello di controllo (in genere a destra, all'interno del dashboard) mostrerà i vari componenti di tale GameObject, con Transform nella parte superiore, seguito da Fotocamera e altri componenti. Sarà necessario reimpostare la trasformazione della fotocamera principale, in modo che sia posizionata correttamente.

3. A tale scopo, selezionare l'icona a forma di ingranaggio accanto al componente Trasforma della fotocamera e selezionare Reimposta.

   

4. Il componente Transform dovrebbe quindi essere simile al seguente:

   1. La posizione è impostata su 0, 0, 0

   2. La rotazione è impostata su 0, 0, 0

   3. E Scale è impostato su 1, 1, 1

      

5. Successivamente, con l'oggetto Fotocamera principale selezionato, vedere il pulsante Aggiungi componente che si trova nella parte inferiore del Pannello di controllo.

6. Selezionare il pulsante e cercare (digitando Origine audio nel campo di ricerca o esplorando le sezioni) per il componente denominato Origine audio come illustrato di seguito e selezionarlo (premendo INVIO su di esso funziona anche).

7. Un componente Origine audio verrà aggiunto alla fotocamera principale, come illustrato di seguito.

   

   Nota

   Per Microsoft HoloLens, dovrai anche modificare quanto segue, che fanno parte del componente Fotocamera nella fotocamera principale:

   • Cancella flag: colore a tinta unita.
   • Sfondo 'Nero, Alfa 0' - Colore esadecimale: #00000000.

Capitolo 4 - Configurare l'area di disegno di debug

Per visualizzare l'input e l'output della traduzione, è necessario creare un'interfaccia utente di base. Per questo corso si creerà un oggetto canvas dell'interfaccia utente, con diversi oggetti "Text" per mostrare i dati.

1. Fare clic con il pulsante destro del mouse in un'area vuota del pannello Gerarchia, nell'interfaccia utente aggiungere un'area di disegno.

   

2. Con l'oggetto Canvas selezionato, nel pannello di controllo (all'interno del componente "Canvas"), impostare Modalità rendering su Spazio globale.

3. Modificare quindi i parametri seguenti nella trasformazione Rect del pannello di controllo:

   1. POS - X 0 Y 0 Z 40

   2. Larghezza - 500

   3. Altezza - 300

   4. Scala - X 0.13 Y 0.13 Z 0.13

      

4. Fare clic con il pulsante destro del mouse sull'area di disegno nel pannello Gerarchia, nell'interfaccia utente e aggiungere un pannello. Questo pannello fornirà uno sfondo al testo che verrà visualizzato nella scena.

5. Fare clic con il pulsante destro del mouse sul Pannello della gerarchia, nell'interfaccia utente e aggiungere un oggetto Text. Ripetere lo stesso processo fino a quando non sono stati creati quattro oggetti Text dell'interfaccia utente in totale (hint: se è selezionato il primo oggetto 'Text', è sufficiente premere 'CTRL' + 'D', per duplicarlo, fino a quando non si dispone di quattro in totale).

6. Per ogni oggetto text selezionarlo e usare le tabelle seguenti per impostare i parametri nel pannello di controllo.

   1. Per il componente Rect Transform :

      Nome	Trasforma - Posizione	Larghezza	Altezza
      MicrophoneStatusLabel	X -80 Y 90 Z 0	300	30
      AzureResponseLabel	X -80 Y 30 Z 0	300	30
      DictationLabel	X -80 Y -30 Z 0	300	30
      TranslationResultLabel	X -80 Y -90 Z 0	300	30

   2. Per il componente Testo (script):

      Nome	Testo	Dimensioni carattere
      MicrophoneStatusLabel	Stato microfono:	20
      AzureResponseLabel	Risposta Web di Azure	20
      DictationLabel	Hai appena detto:	20
      TranslationResultLabel	Traduzione:	20

      

   3. Inoltre, imposta lo stile carattere in grassetto. In questo modo il testo sarà più facile da leggere.

      

7. Per ogni oggetto Text dell'interfaccia utente creato nel capitolo 5, creare un nuovo oggetto Text dell'interfaccia utente figlio. Questi elementi figlio visualizzeranno l'output dell'applicazione. Creare oggetti figlio facendo clic con il pulsante destro del mouse sul padre desiderato(ad esempio MicrophoneStatusLabel) e quindi selezionare Interfaccia utente e quindi selezionare Testo.

8. Per ognuno di questi elementi figlio, selezionarlo e usare le tabelle seguenti per impostare i parametri nel Pannello di controllo.

   1. Per il componente Rect Transform :

      Nome	Trasforma - Posizione	Larghezza	Altezza
      MicrophoneStatusText	X 0 Y -30 Z 0	300	30
      AzureResponseText	X 0 Y -30 Z 0	300	30
      DictationText	X 0 Y -30 Z 0	300	30
      TranslationResultText	X 0 Y -30 Z 0	300	30

   2. Per il componente Testo (script):

      Nome	Testo	Dimensioni carattere
      MicrophoneStatusText	??	20
      AzureResponseText	??	20
      DictationText	??	20
      TranslationResultText	??	20

9. Selezionare quindi l'opzione di allineamento "centrale" per ogni componente di testo:

   

10. Per garantire che gli oggetti text dell'interfaccia utente figlio siano facilmente leggibili, modificarne il colore. A tale scopo, fare clic sulla barra (attualmente "Nero") accanto a Colore.

    

11. Quindi, nella finestra nuovo, piccolo, colore , modificare il colore esadecimale in: 0032EAFF

    

12. Di seguito è riportato l'aspetto dell'interfaccia utente .

    1. Nel pannello Gerarchia:

       

    2. Nelle visualizzazioni scena e gioco:

       

Capitolo 5: Creare la classe Results

Il primo script che è necessario creare è la classe Results , che è responsabile di fornire un modo per visualizzare i risultati della traduzione. La classe archivia e visualizza quanto segue:

• Risultato della risposta da Azure.
• Stato del microfono.
• Risultato della dettatura (voce in testo).
• Risultato della traduzione.

Per creare questa classe:

1. Fare clic con il pulsante destro del mouse nel pannello del progetto, quindi scegliere Crea > cartella. Denominare la cartella Scripts.

   

   

2. Con la cartella Scripts create, fare doppio clic su di esso per aprirlo. Quindi all'interno di tale cartella fare clic con il pulsante destro del mouse e scegliere Crea >e quindi Script C#. Denominare i risultati dello script.

   

3. Fare doppio clic sul nuovo script Risultati per aprirlo con Visual Studio.

4. Inserire gli spazi dei nomi seguenti:

       using UnityEngine;
       using UnityEngine.UI;
   

5. All'interno della classe inserire le variabili seguenti:

       public static Results instance;
   
       [HideInInspector] 
       public string azureResponseCode;
   
       [HideInInspector] 
       public string translationResult;
   
       [HideInInspector] 
       public string dictationResult;
   
       [HideInInspector] 
       public string micStatus;
   
       public Text microphoneStatusText;
   
       public Text azureResponseText;
   
       public Text dictationText;
   
       public Text translationResultText;
   

6. Aggiungere quindi il metodo Awake(), che verrà chiamato quando la classe viene inizializzata.

       private void Awake() 
       { 
           // Set this class to behave similar to singleton 
           instance = this;           
       } 
   

7. Infine, aggiungere i metodi responsabili dell'output delle varie informazioni sui risultati nell'interfaccia utente.

       /// <summary>
       /// Stores the Azure response value in the static instance of Result class.
       /// </summary>
       public void SetAzureResponse(string result)
       {
           azureResponseCode = result;
           azureResponseText.text = azureResponseCode;
       }
   
       /// <summary>
       /// Stores the translated result from dictation in the static instance of Result class. 
       /// </summary>
       public void SetDictationResult(string result)
       {
           dictationResult = result;
           dictationText.text = dictationResult;
       }
   
       /// <summary>
       /// Stores the translated result from Azure Service in the static instance of Result class. 
       /// </summary>
       public void SetTranslatedResult(string result)
       {
           translationResult = result;
           translationResultText.text = translationResult;
       }
   
       /// <summary>
       /// Stores the status of the Microphone in the static instance of Result class. 
       /// </summary>
       public void SetMicrophoneStatus(string result)
       {
           micStatus = result;
           microphoneStatusText.text = micStatus;
       }
   

8. Assicurarsi di salvare le modifiche in Visual Studio prima di tornare a Unity.

Capitolo 6: Creare la classe MicrophoneManager

La seconda classe che creerai è MicrophoneManager.

Questa classe è responsabile di:

• Rilevamento del dispositivo di registrazione collegato al visore VR o al computer (a seconda del valore predefinito).
• Acquisire l'audio (voce) e usare la dettatura per archiviarla come stringa.
• Una volta sospesa la voce, inviare la dettatura alla classe Translator.
• Ospitare un metodo che può arrestare l'acquisizione vocale, se necessario.

Per creare questa classe:

1. Fare doppio clic sulla cartella Scripts per aprirla.

2. Fare clic con il pulsante destro del mouse all'interno della cartella Scripts e scegliere Crea > script C#. Assegnare allo script il nome MicrophoneManager.

3. Fare doppio clic sul nuovo script per aprirlo con Visual Studio.

4. Aggiornare gli spazi dei nomi in modo che corrispondano ai seguenti, nella parte superiore della classe MicrophoneManager :

       using UnityEngine; 
       using UnityEngine.Windows.Speech;
   

5. Aggiungere quindi le variabili seguenti all'interno della classe MicrophoneManager :

       // Help to access instance of this object 
       public static MicrophoneManager instance; 
   
       // AudioSource component, provides access to mic 
       private AudioSource audioSource; 
   
       // Flag indicating mic detection 
       private bool microphoneDetected; 
   
       // Component converting speech to text 
       private DictationRecognizer dictationRecognizer; 
   

6. È ora necessario aggiungere il codice per i metodi Awake() e Start(). Questi verranno chiamati quando la classe inizializza:

       private void Awake() 
       { 
           // Set this class to behave similar to singleton 
           instance = this; 
       } 
   
       void Start() 
       { 
           //Use Unity Microphone class to detect devices and setup AudioSource 
           if(Microphone.devices.Length > 0) 
           { 
               Results.instance.SetMicrophoneStatus("Initialising..."); 
               audioSource = GetComponent<AudioSource>(); 
               microphoneDetected = true; 
           } 
           else 
           { 
               Results.instance.SetMicrophoneStatus("No Microphone detected"); 
           } 
       } 
   

7. È possibile eliminare il metodo Update() perché questa classe non la userà.

8. A questo punto sono necessari i metodi usati dall'app per avviare e arrestare l'acquisizione vocale e passarla alla classe Translator , che verrà compilata a breve. Copiare il codice seguente e incollarlo sotto il metodo Start().

       /// <summary> 
       /// Start microphone capture. Debugging message is delivered to the Results class. 
       /// </summary> 
       public void StartCapturingAudio() 
       { 
           if(microphoneDetected) 
           {               
               // Start dictation 
               dictationRecognizer = new DictationRecognizer(); 
               dictationRecognizer.DictationResult += DictationRecognizer_DictationResult; 
               dictationRecognizer.Start(); 
   
               // Update UI with mic status 
               Results.instance.SetMicrophoneStatus("Capturing..."); 
           }      
       } 
   
       /// <summary> 
       /// Stop microphone capture. Debugging message is delivered to the Results class. 
       /// </summary> 
       public void StopCapturingAudio() 
       { 
           Results.instance.SetMicrophoneStatus("Mic sleeping"); 
           Microphone.End(null); 
           dictationRecognizer.DictationResult -= DictationRecognizer_DictationResult; 
           dictationRecognizer.Dispose(); 
       }
   

   Suggerimento

   Anche se questa applicazione non userà questa applicazione, anche il metodo StopCapturingAudio() è stato fornito qui, se si vuole implementare la possibilità di interrompere l'acquisizione dell'audio nell'applicazione.

9. È ora necessario aggiungere un gestore di dettatura che verrà richiamato quando la voce si arresta. Questo metodo passerà quindi il testo dettato alla classe Translator .

       /// <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.SetDictationResult(text);
   
           // Start the coroutine that process the dictation through Azure 
           StartCoroutine(Translator.instance.TranslateWithUnityNetworking(text));   
       }
   

10. Assicurarsi di salvare le modifiche in Visual Studio prima di tornare a Unity.

Avviso

A questo punto si noterà un errore visualizzato nel pannello della console dell'editor di Unity ("Il nome 'Translator' non esiste..."). Questo perché il codice fa riferimento alla classe Translator , che verrà creata nel capitolo successivo.

Capitolo 7: Chiamare il servizio Azure e traduttore

L'ultimo script da creare è la classe Translator .

Questa classe è responsabile di:

• Autenticazione dell'app con Azure, in cambio di un token di autenticazione.
• Usare il token di autenticazione per inviare testo (ricevuto dalla classe MicrophoneManager ) da tradurre.
• Ricevere il risultato tradotto e passarlo alla classe Results da visualizzare nell'interfaccia utente.

Per creare questa classe:

1. Passare alla cartella Scripts creata in precedenza.

2. Fare clic con il pulsante destro del mouse nel pannello del progetto, Crea > script C#. Chiamare lo script Translator.

3. Fare doppio clic sul nuovo script traduttore per aprirlo con Visual Studio.

4. Aggiungere gli spazi dei nomi seguenti all'inizio del file:

       using System;
       using System.Collections;
       using System.Xml.Linq;
       using UnityEngine;
       using UnityEngine.Networking;
   

5. Aggiungere quindi le variabili seguenti all'interno della classe Translator :

       public static Translator instance; 
       private string translationTokenEndpoint = "https://api.cognitive.microsoft.com/sts/v1.0/issueToken"; 
       private string translationTextEndpoint = "https://api.microsofttranslator.com/v2/http.svc/Translate?"; 
       private const string ocpApimSubscriptionKeyHeader = "Ocp-Apim-Subscription-Key"; 
   
       //Substitute the value of authorizationKey with your own Key 
       private const string authorizationKey = "-InsertYourAuthKeyHere-"; 
       private string authorizationToken; 
   
       // languages set below are: 
       // English 
       // French 
       // Italian 
       // Japanese 
       // Korean 
       public enum Languages { en, fr, it, ja, ko }; 
       public Languages from = Languages.en; 
       public Languages to = Languages.it; 
   

   Nota

   • Le lingue inserite nell'enumerazione delle lingue sono solo esempi. È possibile aggiungere altro se lo si desidera; l'API supporta più di 60 lingue (incluso Klingon)!
   • Esiste una pagina più interattiva che copre le lingue disponibili, anche se tenere presente che la pagina sembra funzionare solo quando la lingua del sito è impostata su "" (e il sito Microsoft probabilmente reindirizzerà alla lingua nativa). È possibile modificare la lingua del sito nella parte inferiore della pagina o modificando l'URL.
   • Il valore authorizationKey, nel frammento di codice precedente, deve essere la chiave ricevuta quando è stata effettuata la sottoscrizione all'API Traduzione testuale di Azure. Questo argomento è stato trattato nel capitolo 1.

6. È ora necessario aggiungere il codice per i metodi Awake() e Start().

7. In questo caso, il codice eseguirà una chiamata ad Azure usando la chiave di autorizzazione per ottenere un token.

       private void Awake() 
       { 
           // Set this class to behave similar to singleton  
           instance = this; 
       } 
   
       // Use this for initialization  
       void Start() 
       { 
           // When the application starts, request an auth token 
           StartCoroutine("GetTokenCoroutine", authorizationKey); 
       }
   

   Nota

   Il token scadrà dopo 10 minuti. A seconda dello scenario per l'app, potrebbe essere necessario effettuare la stessa chiamata coroutine più volte.

8. La coroutine per ottenere il token è la seguente:

       /// <summary> 
       /// Request a Token from Azure Translation Service by providing the access key. 
       /// Debugging result is delivered to the Results class. 
       /// </summary> 
       private IEnumerator GetTokenCoroutine(string key)
       {
           if (string.IsNullOrEmpty(key))
           {
               throw new InvalidOperationException("Authorization key not set.");
           }
   
           using (UnityWebRequest unityWebRequest = UnityWebRequest.Post(translationTokenEndpoint, string.Empty))
           {
               unityWebRequest.SetRequestHeader("Ocp-Apim-Subscription-Key", key);
               yield return unityWebRequest.SendWebRequest();
   
               long responseCode = unityWebRequest.responseCode;
   
               // Update the UI with the response code 
               Results.instance.SetAzureResponse(responseCode.ToString());
   
               if (unityWebRequest.isNetworkError || unityWebRequest.isHttpError)
               {
                   Results.instance.azureResponseText.text = unityWebRequest.error;
                   yield return null;
               }
               else
               {
                   authorizationToken = unityWebRequest.downloadHandler.text;
               }
           }
   
           // After receiving the token, begin capturing Audio with the MicrophoneManager Class 
           MicrophoneManager.instance.StartCapturingAudio();
       }
   

   Avviso

   Se si modifica il nome del metodo IEnumerator GetTokenCoroutine(), è necessario aggiornare i valori della stringa di chiamata StartCoroutine e StopCoroutine nel codice precedente. Come indicato nella documentazione di Unity, per arrestare una coroutine specifica, è necessario usare il metodo di valore stringa.

9. Aggiungere quindi la coroutine (con un metodo di flusso "support" proprio sotto di esso) per ottenere la traduzione del testo ricevuto dalla classe MicrophoneManager . Questo codice crea una stringa di query da inviare all'API Traduzione testuale di Azure e quindi usa la classe UnityWebRequest interna per effettuare una chiamata 'Get' all'endpoint con la stringa di query. Il risultato viene quindi usato per impostare la traduzione nell'oggetto Results. Il codice seguente illustra l'implementazione:

       /// <summary> 
       /// Request a translation from Azure Translation Service by providing a string.  
       /// Debugging result is delivered to the Results class. 
       /// </summary> 
       public IEnumerator TranslateWithUnityNetworking(string text)
       {
           // This query string will contain the parameters for the translation 
           string queryString = string.Concat("text=", Uri.EscapeDataString(text), "&from=", from, "&to=", to);
   
           using (UnityWebRequest unityWebRequest = UnityWebRequest.Get(translationTextEndpoint + queryString))
           {
               unityWebRequest.SetRequestHeader("Authorization", "Bearer " + authorizationToken);
               unityWebRequest.SetRequestHeader("Accept", "application/xml");
               yield return unityWebRequest.SendWebRequest();
   
               if (unityWebRequest.isNetworkError || unityWebRequest.isHttpError)
               {
                   Debug.Log(unityWebRequest.error);
                   yield return null;
               }
   
               // Parse out the response text from the returned Xml
               string result = XElement.Parse(unityWebRequest.downloadHandler.text).Value;
               Results.instance.SetTranslatedResult(result);
           }
       }
   

10. Assicurarsi di salvare le modifiche in Visual Studio prima di tornare a Unity.

Capitolo 8: Configurare la scena unity

1. Nell'editor di Unity fare clic e trascinare la classe Results dalla cartella Scripts all'oggetto Fotocamera principale nel pannello Gerarchia.

2. Fare clic sulla fotocamera principale e osservare il Pannello di controllo. Si noterà che all'interno del componente script appena aggiunto sono presenti quattro campi con valori vuoti. Questi sono i riferimenti di output alle proprietà nel codice.

3. Trascinare gli oggetti Text appropriati dal pannello Gerarchia a questi quattro slot, come illustrato nell'immagine seguente.

   

4. Fare quindi clic e trascinare la classe Translator dalla cartella Scripts all'oggetto Main Camera nel pannello Gerarchia.

5. Quindi, fare clic e trascinare la classe MicrophoneManager dalla cartella Scripts all'oggetto Camera principale nel pannello Gerarchia.

6. Infine, fare clic sulla fotocamera principale e guardare il Pannello di controllo. Si noterà che nello script trascinato, ci sono due caselle a discesa che consentono di impostare le lingue.

   

Capitolo 9 : Test in realtà mista

A questo punto è necessario verificare che la scena sia stata implementata correttamente.

Assicurarsi che:

• Tutte le impostazioni indicate nel capitolo 1 vengono impostate correttamente.
• Gli script Results, Translator e MicrophoneManager sono associati all'oggetto Main Camera .
• La chiave del servizio API Traduzione testuale di Azure è stata inserita nella variabile authorizationKey all'interno di Translator Script.
• Tutti i campi nel pannello Controllo fotocamera principale vengono assegnati correttamente.
• Il microfono funziona quando si esegue la scena (in caso contrario, verificare che il microfono collegato sia il dispositivo predefinito e che sia stato configurato correttamente in Windows).

È possibile testare il visore VR immersive premendo il pulsante Riproduci nell'editor di Unity. L'app deve funzionare tramite il visore VR immersive collegato.

Avviso

Se viene visualizzato un errore nella console unity relativa alla modifica del dispositivo audio predefinito, la scena potrebbe non funzionare come previsto. Questo è dovuto al modo in cui il portale di realtà mista gestisce i microfoni predefiniti per le cuffie che li hanno. Se viene visualizzato questo errore, arrestare semplicemente la scena e avviarla di nuovo e le operazioni dovrebbero funzionare come previsto.

Capitolo 10: Creare la soluzione UWP e trasferire localmente sul computer locale

Tutto ciò che serve per la sezione Unity di questo progetto è stato completato, quindi è il momento di compilarlo da Unity.

1. Passare a Impostazioni di compilazione: Impostazioni di compilazione file > ...

2. Nella finestra Build Settings (Impostazioni compilazione) fare clic su Build (Compila).

   

3. Se non è già stato fatto, selezionare Progetti C# unity.

4. Fare clic su Compila. Unity avvierà una finestra Esplora file, in cui è necessario creare e quindi selezionare una cartella in cui compilare l'app. Creare ora la cartella e denominarla App. Quindi, con la cartella App selezionata, premere Seleziona cartella.

5. Unity inizierà a compilare il progetto nella cartella App .

6. Una volta completata la compilazione di Unity (potrebbe essere necessario del tempo), verrà aperta una finestra Esplora file nella posizione della compilazione (controllare la barra delle applicazioni, perché potrebbe non essere sempre visualizzata sopra le finestre, ma invierà una notifica dell'aggiunta di una nuova finestra).

Capitolo 11: Distribuire l'applicazione

Per distribuire l'applicazione:

1. Passare alla nuova compilazione unity ( cartella App ) e aprire il file della soluzione con Visual Studio.

2. Nella configurazione della soluzione selezionare Debug.

3. Nella piattaforma della soluzione selezionare x86, Computer locale.

   Per Microsoft HoloLens, potrebbe risultare più semplice impostare questa opzione su Computer remoto, in modo che non si sia collegati al computer. Tuttavia, è necessario eseguire anche le operazioni seguenti:

   • Conoscere l'indirizzo IP di HoloLens, che è possibile trovare all'interno di Impostazioni > Rete e > Internet Wi-Fi > Advanced Options. IPv4 è l'indirizzo da usare.
   • Assicurarsi che la modalità sviluppatore sia attivata. Disponibile in Impostazioni > Aggiornamento e sicurezza > per gli sviluppatori.

   

4. Passare al menu Compila e fare clic su Distribuisci soluzione per trasferire localmente l'applicazione nel PC.

5. L'app dovrebbe ora essere visualizzata nell'elenco delle app installate, pronte per l'avvio.

6. Dopo l'avvio, l'app chiederà di autorizzare l'accesso al microfono. Assicurarsi di fare clic sul pulsante SÌ .

7. A questo punto si è pronti per iniziare a tradurre!

Applicazione API Traduzione testuale completata

È stata creata un'app di realtà mista che usa l'API Traduzione testuale di Azure per convertire il parlato in testo tradotto.

Esercizi aggiuntivi

Esercizio 1

È possibile aggiungere funzionalità di sintesi vocale all'app, in modo che il testo restituito venga pronunciato?

Esercizio 2

Consentire all'utente di modificare le lingue di origine e di output (da" e "a") all'interno dell'app stessa, quindi l'app non deve essere ricompilata ogni volta che vuoi modificare le lingue.