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. Saranno disponibili nuove serie di esercitazioni che verranno pubblicate in futuro che mostreranno come sviluppare per HoloLens 2. Questo avviso verrà aggiornato con un collegamento a tali esercitazioni quando vengono pubblicati.

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 in tempo quasi 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 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 (VR) immersivo (o il microfono predefinito di HoloLens).
2. L'app acquisisce 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 Traduzione in un'applicazione di esempio basata su Unity. Sarà possibile applicare questi concetti a un'applicazione personalizzata che si sta creando.

Supporto di dispositivi

Corso	HoloLens	Visori VR immersive
MR e Azure 301: Traduzione	✔️	✔

Nota

Anche se questo corso si concentra principalmente sulle visori vr (VR) immersivi Windows Mixed Reality, è anche possibile applicare ciò che si impara in questo corso per Microsoft HoloLens. Mentre segui il corso, vedrai 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). Si è liberi di usare il software più recente, come elencato nell'articolo degli strumenti di installazione , anche se non dovrebbe essere considerato che le informazioni in questo corso corrisponderanno perfettamente a ciò che troverete 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 Mixed Reality per lo sviluppo vr (VR) immersivo
• Windows 10 Fall Creators Update (o versioni successive) con modalità sviluppatore abilitata
• L'SDK di Windows 10 più recente
• Unity 2017.4
• Visual Studio 2017
• Visore vr (VR) immersivo Windows Mixed Reality o Microsoft HoloLens con la modalità sviluppatore abilitata
• Un set di cuffie con un microfono predefinito (se il visore non ha un microfono e altoparlanti predefiniti)
• Accesso a Internet per l'installazione e il recupero della traduzione di Azure

Prima di iniziare

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

• Il codice in questa esercitazione consente 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 > voce privacy > , digitando & digitando e selezionando il pulsante Attiva servizi voce e digitando suggerimenti.

• Se usi un microfono e le cuffie connesse a (o predefinite) il visore visore, assicurati che l'opzione "Quando indossare il visore, passare al microfono visore" è attivata in Impostazioni > Realtà mista > Audio e voce.

  

  

Avviso

Tenere presente che se si sta sviluppando per un visore immersivo per questo lab, è possibile che si verifichino problemi di 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. In seguito, 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 dispone già di un account Azure, sarà necessario crearne uno. Se si segue questa esercitazione in una classe o in una situazione del lab, chiedere all'insegnante o a uno dei proctor di 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 fornisce 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 per l'utente, se si tratta della prima volta che si crea un servizio traduzione testuale, è necessario che sia disponibile un piano gratuito (denominato F0).

   4. Scegliere un gruppo di risorse o crearne uno nuovo. Un gruppo di risorse consente di monitorare, controllare l'accesso, 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 del gruppo di risorse.

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

   6. Dovrai anche confermare che hai capito le Condizioni e le condizioni applicate al servizio.

   7. Selezionare Crea.

      

5. Dopo aver fatto clic su Crea, sarà necessario attendere che il servizio venga creato, 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. All'interno di questa esercitazione, l'applicazione dovrà effettuare chiamate al servizio, che viene eseguita tramite 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 ottenere questo risultato facendo clic sul collegamento ipertestuale blu, situato nel menu di spostamento Servizi, denotato dall'icona della chiave). In questo modo verranno rivelate le chiavi del servizio.

11. Eseguire una copia di una delle chiavi visualizzate, perché sarà necessario in un secondo momento nel progetto.

Capitolo 2: Configurare il progetto Unity

Configurare e testare il visore vr vr immersivo per la realtà mista.

Nota

Non sono necessari controller di movimento per questo corso. Se è necessario supportare la configurazione di un visore visore immersivo, seguire questa procedura.

Di seguito è riportata una configurazione tipica per lo sviluppo con 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. Inserire MR_Translation. Assicurarsi che il tipo di progetto sia impostato su 3D. Impostare La posizione su un punto appropriato per l'utente (ricordarsi, più vicino alle directory radice è meglio). 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 script esterno in Visual Studio 2017. Chiudere la finestra Preferenze .

   

4. Passare quindi a Impostazioni di compilazione file > e passare alla piattaforma in 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. SDK è impostato su Più recente installato

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

   5. Compilare ed eseguire è impostato su Computer locale

   6. Salvare la scena e aggiungerla alla compilazione.

      1. Eseguire questa operazione selezionando Aggiungi scene aperte. Verrà visualizzata una finestra di salvataggio.

         

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

         

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

         

         Tenere presente che è necessario salvare le scene di Unity all'interno della cartella Asset , perché devono essere associate al progetto Unity. La creazione della cartella scene (e altre cartelle simili) è un modo tipico per 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 , verrà aperto 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 script deve essere stabile (equivalente.NET 3.5).

      2. Scripting Back-end 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 (trovate sotto Le impostazioni di pubblicazione), selezionare Virtual Reality Supportato, assicurarsi che l'SDK di Windows Mixed Reality venga aggiunto.

      

8. Torna 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 Set up 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 gerarchia si troverà un oggetto denominato Main Camera, questo oggetto rappresenta il punto di vista "head" una volta che si è "all'interno" dell'applicazione.

2. Con il dashboard unity davanti all'utente selezionare Main Camera GameObject. Si noterà che il pannello di controllo (in genere trovato a destra, all'interno del dashboard) mostrerà i vari componenti di quel GameObject, con Trasformazione nella parte superiore, seguita da Fotocamera e altri componenti. Sarà necessario reimpostare la trasformazione della fotocamera principale, quindi è posizionata correttamente.

3. A tale scopo, selezionare l'icona 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 situato nella parte inferiore del pannello di controllo.

6. Selezionare tale pulsante e cercare (digitando l'origine audio nel campo di ricerca o spostando le sezioni) per il componente denominato Origine audio , come illustrato di seguito e selezionarlo (premendo invio funziona anche).

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

   

   Nota

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

   • Cancella flag: Colore a tinta unita.
   • Priorità bassa 'Nero, Alfa 0' - Colore esadecimale: #000000000.

Capitolo 4 - Configurazione dell'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 Interfaccia utente Canvas, con diversi oggetti "Text" per visualizzare i dati.

1. Fare clic con il pulsante destro del mouse su un'area vuota del pannello gerarchia, nell'interfaccia utente aggiungere un'area Canvas.

   

2. Con l'oggetto Canvas selezionato, nel pannello di controllo (all'interno del componente "Canvas"), modificare la modalità di rendering in Spazio mondiale.

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 fornisce 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 Testo interfaccia utente in totale (Hint: se si dispone del primo oggetto 'Text' selezionato, è sufficiente premere 'CTRL' + 'D', per duplicarlo, fino a quando non si dispone di quattro in totale).

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

   1. Per il componente Trasformazione rect :

      Nome	Trasformazione - 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	Dimensione carattere
      MicrophoneStatusLabel	Stato microfono:	20
      AzureResponseLabel	Risposta Web di Azure	20
      DictationLabel	Hai appena detto:	20
      TranslationResultLabel	Conversione:	20

      

   3. Imposta anche lo stile del 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 utentefiglio. 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	Dimensione 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. Nella scena e nelle visualizzazioni del 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. Assegnare alla cartella il nome Scripts.

   

   

2. Dopo aver creato la cartella Scripts , 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 viene inizializzata la classe .

       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 all'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.
• Dopo aver sospeso la voce, inviare la dettatura alla classe Translator.
• Ospitare un metodo in grado di 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 Script , 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 lo 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 lo userà, il metodo StopCapturingAudio() è stato fornito anche qui, se si vuole implementare la possibilità di arrestare l'acquisizione dell'audio nell'applicazione.

9. È ora necessario aggiungere un gestore di dettatura che verrà richiamato all'arresto della voce. Questo metodo passerà quindi il testo determinato 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 'Traduttore' non esiste..."). Ciò è dovuto al fatto che il codice fa riferimento alla classe Translator , che verrà creata nel capitolo successivo.

Capitolo 7: Chiamare al 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 translator 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 nelle lingue enumerazione sono solo esempi. È possibile aggiungere altro se si desidera; l'API supporta più di 60 lingue (incluso Klingon)!
   • È disponibile 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 al momento della 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 effettuerà 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 eseguire la stessa chiamata di 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. In base alla 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 utilizzato 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 Resultsdalla cartella Scripts all'oggetto Main Camera nel pannello Hierarchy( 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. Si tratta dei 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. Fare quindi clic e trascinare la classe MicrophoneManager dalla cartella Scripts all'oggetto Main Camera nel Pannello gerarchia.

6. Infine, fare clic sulla fotocamera principale e osservare il Pannello di controllo. Si noterà che nello script trascinato sono presenti due caselle a discesa che consentiranno 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 collegati all'oggetto Main Camera .
• La chiave del servizio API Traduzione testuale di Azure è stata inserita all'interno della variabile authorizationKey all'interno di Translator Script.
• Tutti i campi nel pannello Controllo fotocamera principale vengono assegnati correttamente.
• Il microfono funziona durante l'esecuzione della scena (in caso contrario, verificare che il microfono collegato sia il dispositivo predefinito e che sia stato configurato correttamente all'interno di Windows).

È possibile testare il visore VR immersive premendo il pulsante Riproducinell'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 i visori VR che li hanno. Se viene visualizzato questo errore, è sufficiente arrestare la scena e riavviarla e le operazioni dovrebbero funzionare come previsto.

Capitolo 10: Creare la soluzione UWP e il sideload nel computer locale

Tutto il necessario per la sezione Unity di questo progetto è stato completato, quindi è il momento di compilarlo da Unity.

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

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

   

3. In caso contrario, selezionare Progetti C# unity.

4. Fare clic su Compila. Unity avvierà una finestra di Esplora file, in cui è necessario creare e quindi selezionare una cartella in cui compilare l'app. Creare 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 di 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 di Unity (cartella App ) e aprire il file della soluzione con Visual Studio.

2. In Configurazione soluzione selezionare Debug.

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

   Per la Microsoft HoloLens, è possibile che sia 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 del dispositivo HoloLens, disponibile all'interno di Impostazioni > Rete & Internet > Wi-Fi > Opzioni avanzate. IPv4 è l'indirizzo da usare.
   • Verificare che la modalità sviluppatore sia attivata; disponibile in Impostazioni > Aggiornamento & 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, pronto 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 DELL'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 parlato?

Esercizio 2

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