Nota
L'accesso a questa pagina richiede l'autorizzazione. È possibile provare ad accedere o modificare le directory.
L'accesso a questa pagina richiede l'autorizzazione. È possibile provare a modificare le directory.
Nota
Le esercitazioni della Realtà mista Academy sono state progettate tenendo conto di HoloLens (prima generazione) e visori VR immersive per realtà mista. Pertanto, riteniamo importante lasciare queste esercitazioni per gli sviluppatori che sono ancora alla ricerca di una guida per lo sviluppo di tali dispositivi. Queste esercitazioni non verranno aggiornate con i set di strumenti o le interazioni più recenti usati per HoloLens 2. Verranno mantenuti per continuare a funzionare sui dispositivi supportati. In futuro verrà pubblicata una nuova serie di esercitazioni che dimostreranno come sviluppare per HoloLens 2. Questo avviso verrà aggiornato con un collegamento a tali tutorial quando vengono pubblicati.
In questo corso imparerai a riconoscere il contenuto visivo personalizzato all'interno di un'immagine fornita, usando le funzionalità Azure Visione personalizzata in un'applicazione di realtà mista.
Questo servizio ti consentirà di addestrare un modello di apprendimento automatico utilizzando le immagini degli oggetti. Utilizzerai quindi il modello sottoposto a training per riconoscere oggetti simili, come fornito dall'acquisizione della fotocamera di Microsoft HoloLens o da una fotocamera connessa al PC per i visori VR immersivi.
Azure Visione personalizzata è un servizio cognitivo Microsoft che consente agli sviluppatori di creare classificatori di immagini personalizzati. Questi classificatori possono quindi essere utilizzati con nuove immagini per riconoscere o classificare gli oggetti all'interno di quella nuova immagine. Il servizio fornisce un portale online semplice e facile da usare per semplificare il processo. Per altre informazioni, visita la pagina del servizio Azure Visione personalizzata.
Al termine di questo corso, disporrai di un'applicazione di realtà mista che sarà in grado di funzionare in due modalità:
Modalità di analisi: impostazione manuale del servizio di Visione personalizzata caricando immagini, creando tag e addestrando il servizio a riconoscere diversi oggetti (in questo caso mouse e tastiera). Creerai quindi un'app HoloLens che catturerà immagini tramite la fotocamera e proverà a riconoscerle nel mondo reale.
Modalità di allenamento: implementerai un codice che abiliterà una "modalità di allenamento" nella tua app. La modalità di training ti consentirà di acquisire immagini usando la fotocamera di HoloLens, caricare le immagini acquisite nel servizio ed eseguire il training del modello di visione personalizzato.
Questo corso ti insegnerà come ottenere i risultati del servizio di Visione personalizzata in un'applicazione di esempio basata su Unity. Spetterà a te applicare questi concetti a un'applicazione personalizzata che potresti creare.
Supporto per dispositivi
| Portata | HoloLens | Visori VR immersive |
|---|---|---|
| MR e Azure 302b: Visione personalizzata | ✔️ | ✔️ |
Nota
Anche se questo corso è incentrato principalmente su HoloLens, puoi applicare ciò che impari in questo corso anche ai visori VR immersive (VR) di Windows Mixed Reality. Poiché i visori VR immersive (VR) non dispongono di fotocamere accessibili, sarà necessario collegare una fotocamera esterna al PC. Seguendo il corso, verranno visualizzate le note su eventuali modifiche che potrebbe essere necessario apportare per supportare i visori VR immersive (VR).
Prerequisiti
Nota
Questa esercitazione è progettata per gli sviluppatori che hanno esperienza di base con Unity e C#. Si prega inoltre di essere consapevoli del fatto che i prerequisiti e le istruzioni scritte all'interno di questo documento rappresentano ciò che è stato testato e verificato al momento della stesura (luglio 2018). Sei libero di utilizzare il software più recente, come elencato nell'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 di quello elencato di seguito.
Per questo corso sono consigliati l'hardware e il software seguenti:
- Un PC di sviluppo, compatibile con Windows Mixed Reality per lo sviluppo di visori VR immersive (VR)
- Windows 10 Fall Creators Update (o versione successiva) con modalità sviluppatore abilitata
- La versione più recente di Windows 10 SDK
- Unità 2017.4
- Visual Studio 2017
- Un visore VR immersivo di Windows Mixed Reality oMicrosoft HoloLens con la modalità sviluppatore abilitata
- Una fotocamera connessa al PC (per lo sviluppo di un visore VR immersivo)
- Accesso a Internet per la configurazione di Azure e recupero API Visione personalizzata
- Una serie di almeno cinque (5) immagini (dieci (10) consigliate) per ogni oggetto che si desidera che il servizio di Visione personalizzata riconosca. Se lo desideri, puoi utilizzare le immagini già fornite con questo corso (un mouse per computer e una tastiera).
Prima di iniziare
- Per evitare problemi durante la creazione di questo progetto, è consigliabile creare il progetto menzionato in questa esercitazione in una cartella radice o quasi radice (i percorsi di cartelle lunghi possono causare problemi in fase di compilazione).
- Configurare e testare il dispositivo HoloLens. Se hai bisogno di supporto per configurare il tuo dispositivo HoloLens, assicurati di visitare l'articolo relativo alla configurazione di HoloLens.
- È consigliabile eseguire la calibrazione e l'ottimizzazione del sensore quando si inizia a sviluppare una nuova app HoloLens. A volte può essere utile eseguire queste attività per ogni utente.
Per informazioni sulla calibrazione, segui questo collegamento all'articolo sulla calibrazione di HoloLens.
Per informazioni sulla regolazione del sensore, segui questo collegamento all'articolo sulla regolazione del sensore HoloLens.
Capitolo 1 - Il portale del servizio Visione personalizzata
Per usare il servizio di Visione personalizzata in Azure, è necessario configurare un'istanza del servizio da rendere disponibile per l'applicazione.
Innanzitutto, passare alla pagina principale del servizio di Visione personalizzata.
Fai clic sul pulsante Inizia .
Accedere al portale del servizio Visione personalizzata.
Nota
Se non si ha già un account di Azure, è necessario crearne uno. Se stai seguendo questa esercitazione in classe o in un laboratorio, chiedi aiuto al tuo istruttore o a uno dei supervisori per configurare il tuo nuovo account.
Dopo aver effettuato l'accesso per la prima volta, verrà visualizzato il pannello Termini di servizio . Fai clic sulla casella di controllo per accettare i termini. Quindi fai clic su Accetto.
Dopo aver accettato i Termini, verrai indirizzato alla sezione Progetti del Portale. Fare clic su Nuovo progetto.
Apparirà una scheda sul lato destro, che ti chiederà di specificare alcuni campi per il progetto.
Inserire un nome per il progetto.
Inserire una descrizione per il progetto (facoltativo).
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 risorse di Azure. È consigliabile mantenere tutti i servizi di Azure associati a un singolo progetto (ad esempio questi corsi) in un gruppo di risorse comune.
Impostare i tipi di progetto su Classificazione
Impostare i domini come Generale.
Per altre informazioni sui gruppi di risorse di Azure, vedere l'articolo sui gruppi di risorse.
Una volta terminato, clicca su Crea progetto, verrai reindirizzato al Servizio di Visione personalizzata, pagina del progetto.
Capitolo 2 - Formazione del progetto di Visione personalizzata
Una volta nel portale Visione personalizzata, l'obiettivo principale è addestrare il progetto a riconoscere oggetti specifici nelle immagini. Sono necessarie almeno cinque (5) immagini, anche se dieci (10) è preferibile, per ogni oggetto che si vuole che l'applicazione riconosca. È possibile utilizzare le immagini fornite con questo corso (un mouse per computer e una tastiera).
Per eseguire il training del progetto del servizio di Visione personalizzata:
Fai clic sul + pulsante accanto a Tag.
Aggiungi il nome dell'oggetto che desideri riconoscere. Fare clic su Salva.
Noterai che il tuo tag è stato aggiunto (potrebbe essere necessario ricaricare la pagina per visualizzarlo). Fare clic sulla casella di controllo accanto al nuovo tag, se non è già selezionata.
Clicca su Aggiungi immagini al centro della pagina.
Fare clic su Sfoglia file locali e cercare, quindi selezionare, le immagini che si desidera caricare, con un minimo di cinque (5). Ricorda che tutte queste immagini dovrebbero contenere l'oggetto che stai addestrando.
Nota
È possibile selezionare più immagini alla volta da caricare.
Una volta visualizzate le immagini nella scheda, selezionare il tag appropriato nella casella I miei tag .
Fare clic su Carica file. Verrà avviato il caricamento dei file. Una volta ottenuta la conferma del caricamento, fare clic su Fine.
Ripeti la stessa procedura per creare un nuovo tag denominato Tastiera e caricare le foto appropriate per esso. Assicurati di deselezionareMouse dopo aver creato i nuovi tag, in modo da mostrare la finestra Aggiungi immagini .
Dopo aver configurato entrambi i tag, fai clic su Train e verrà avviata la creazione della prima iterazione di training.
Una volta compilato, sarà possibile vedere due pulsanti denominati Rendi predefinito e URL di previsione. Fai clic prima su Rendi predefinito , quindi fai clic su URL di previsione.
Nota
L'URL dell'endpoint fornito da questo criterio è impostato sull'iterazione contrassegnata come predefinita. Di conseguenza, se in seguito esegui una nuova iterazione e la aggiorni come predefinita, non dovrai modificare il codice.
Dopo aver fatto clic su URL di previsione, apri Blocco note e copia e incolla l'URL e la chiave di previsione, in modo da poterlo recuperare quando ne avrai bisogno in un secondo momento nel codice.
Fare clic sull'ingranaggio in alto a destra dello schermo.
Copiare la chiave di formazione e incollarla in un Blocco note per un uso successivo.
Copiare anche l'ID progetto e incollarlo nel file del Blocco note per un uso successivo.
Capitolo 3 - Configurare il progetto Unity
Quella che segue è una configurazione tipica per lo sviluppo con la realtà mista e, come tale, è un buon modello per altri progetti.
Apri Unity e fai clic su Nuovo.
A questo punto sarà necessario specificare un nome per il progetto Unity. Inserire AzureCustomVision. Verifica che il modello di progetto sia impostato su 3D. Imposta la posizione in un posto appropriato per te (ricorda, più vicino alle directory radice è meglio). Quindi, fai clic su Crea progetto.
Con Unity aperto, vale la pena verificare che l'editor di script predefinito sia impostato su Visual Studio. Vai su Modifica>preferenze e quindi nella nuova finestra vai su Strumenti esterni. Modificare l'editor di script esterno in Visual Studio 2017. Chiudere la finestra Preferenze .
Passare quindi a Impostazioni compilazione file > e selezionare Piattaforma UWP UWP (piattaforma UWP universale), quindi fare clic sul pulsante Cambia piattaforma per applicare la selezione.
Mentre sei ancora nelle impostazioni di compilazione dei file > e assicurati che:
Il dispositivo di destinazione è impostato su HoloLens
Per i visori VR immersive imposta Dispositivo di destinazione su qualsiasi dispositivo.
Il tipo di build è impostato su D3D
L'SDK è impostato su Ultima installata
Versione di Visual Studio è impostata su Ultima installata
Compila ed esegui è impostato su Computer locale
Salva la scena e aggiungila alla build.
A tale scopo, selezionare Aggiungi scene aperte. Verrà visualizzata una finestra di salvataggio.
Crea una nuova cartella per questa e per qualsiasi scena futura, quindi seleziona il pulsante Nuova cartella , per creare una nuova cartella, chiamala Scenes.
Apri la cartella Scene appena creata, quindi nel campo di testo Nome file: digita CustomVisionScene, quindi fai clic su Salva.
Tieni presente che devi salvare le scene di Unity nella cartella Assets , perché devono essere associate al progetto Unity. La creazione della cartella scene (e di altre cartelle simili) è un modo tipico di strutturare un progetto Unity.
Per il momento, le impostazioni rimanenti in Impostazioni compilazione dovrebbero essere lasciate come predefinite.
Nella finestra Impostazioni di costruzione, fai clic sul pulsante Impostazioni del giocatore, questo aprirà il relativo pannello nello spazio in cui si trova l'Ispettore.
In questo pannello è necessario verificare alcune impostazioni:
Nella scheda Altre impostazioni :
La versione di runtime degli script deve essere sperimentale (equivalente a .NET 4.6), il che comporta la necessità di riavviare l'Editor.
Il back-end di scripting deve essere .NET
Il livello di compatibilità dell'API deve essere .NET 4.6
Nella scheda Impostazioni di pubblicazione , in Funzionalità, selezionare:
InternetClient
Webcam
Microfono
Più in basso nel pannello, in Impostazioni XR (che si trova sotto Impostazioni di pubblicazione), seleziona Realtà virtuale supportata, assicurati che sia stato aggiunto l'SDK Windows Mixed Reality.
Tornando alle impostazioni di compilazione, Unity C# Projects non è più disattivato; Seleziona la casella di controllo accanto a questa opzione.
Chiudere la finestra Impostazioni di compilazione.
Salva la scena e il progetto (FILE > SAVE SCENE / FILE > SAVE PROJECT).
Capitolo 4 - Importazione della DLL Newtonsoft in Unity
Importante
Se si vuole ignorare il componente Unity Set up di questo corso e continuare direttamente con il codice, è possibile scaricare questo pacchetto di Azure-MR-302b.unitypackage, importarlo nel progetto come pacchetto personalizzato e quindi continuare dal capitolo 6.
Questo corso richiede l'uso della libreria Newtonsoft , che puoi aggiungere come DLL alle tue risorse. Il pacchetto contenente questa libreria può essere scaricato da questo link. Per importare la libreria Newtonsoft nel tuo progetto, usa il pacchetto Unity fornito con questo corso.
Aggiungere il pacchetto .unitypackage a Unity utilizzando l'opzione di menu Pacchetto>personalizzatodi importazione delle risorse>.
Nella finestra di dialogo Importa pacchetto Unity visualizzata, assicurati che tutto ciò che si trova in Plug-in (incluso) sia selezionato.
Fare clic sul pulsante Importa per aggiungere gli elementi al progetto.
Passare alla cartella Newtonsoft in Plug-in nella visualizzazione del progetto e selezionare il plug-in Newtonsoft.Json.
Con il plug-in Newtonsoft.Json selezionato, assicurati che qualsiasi piattaforma sia deselezionato, quindi assicurati che anche WSAPlayer sia deselezionato, quindi fai clic su Applica. Questo serve solo per confermare che i file sono configurati correttamente.
Nota
Contrassegnando questi plug-in, questi plug-in vengono configurati per essere usati solo nell'editor Unity. Nella cartella WSA è presente un set diverso che verrà usato dopo l'esportazione del progetto da Unity.
Successivamente, è necessario aprire la cartella WSA , all'interno della cartella Newtonsoft . Verrà visualizzata una copia dello stesso file appena configurato. Selezionare il file e quindi verificare che nel controllo
- Qualsiasi piattaforma è deselezionata
- viene controllatosoloWSAPlayer
- Non elaborare è controllato
Capitolo 5 - Configurazione della fotocamera
Nel pannello Gerarchia, seleziona la fotocamera principale.
Una volta selezionato, sarai in grado di vedere tutti i componenti della fotocamera principale nel pannello Inspector.
L'oggetto fotocamera deve essere denominato Fotocamera principale (notare l'ortografia!)
Il tag della fotocamera principale deve essere impostato su MainCamera (notare l'ortografia!)
Assicurarsi che la posizione di trasformazione sia impostata su 0, 0, 0
Imposta Cancella contrassegni su Colore a tinta unita (ignora questa opzione per il visore VR immersivo).
Imposta il colore di sfondo del componente della fotocamera su nero, alfa 0 (codice esadecimale: #00000000) (ignoralo per l'headset immersivo).
Capitolo 6 - Creare la classe CustomVisionAnalyser.
A questo punto sei pronto per scrivere del codice.
Inizierai con la classe CustomVisionAnalyser .
Nota
Le chiamate al servizio di Visione personalizzata effettuate nel codice illustrato di seguito vengono effettuate utilizzando l'API REST di Visione personalizzata. Usando questo, vedrai come implementare e utilizzare questa API (utile per capire come implementare qualcosa di simile da solo). Tenere presente che Microsoft offre un SDK del servizio di Visione personalizzata che può essere usato anche per effettuare chiamate al servizio. Per ulteriori informazioni, visita l'articolo Visione personalizzata Service SDK.
Questa classe si occupa di:
Caricamento dell'immagine più recente acquisita come matrice di byte.
Invio della matrice di byte all'istanza del servizio Visione personalizzata di Azure per l'analisi.
Ricezione della risposta come stringa JSON.
Deserializzazione della risposta e passaggio della previsione risultante alla classe SceneOrganiser , che si occuperà della modalità di visualizzazione della risposta.
Per creare la classe:
Fai clic con il pulsante destro del mouse nella cartella delle risorse situata nel pannello Progetto, quindi fai clic su Crea > cartella. Chiama la cartella Scripts.
Fai doppio clic sulla cartella appena creata, per aprirla.
Fare clic con il pulsante destro del mouse all'interno della cartella, quindi scegliere Crea>script C#. Denomina lo script CustomVisionAnalyser.
Fare doppio clic sul nuovo script CustomVisionAnalyser per aprirlo con Visual Studio.
Aggiorna gli spazi dei nomi nella parte superiore del file in modo che corrispondano a quanto segue:
using System.Collections; using System.IO; using UnityEngine; using UnityEngine.Networking; using Newtonsoft.Json;Nella classe CustomVisionAnalyser , aggiungi le seguenti variabili:
/// <summary> /// Unique instance of this class /// </summary> public static CustomVisionAnalyser Instance; /// <summary> /// Insert your Prediction Key here /// </summary> private string predictionKey = "- Insert your key here -"; /// <summary> /// Insert your prediction endpoint here /// </summary> private string predictionEndpoint = "Insert your prediction endpoint here"; /// <summary> /// Byte array of the image to submit for analysis /// </summary> [HideInInspector] public byte[] imageBytes;Nota
Assicurarsi di inserire la chiave di completamento nella variabile predictionKey e l'endpoint di completamento nella variabile predictionEndpoint . Queste informazioni sono state copiate in Blocco note in precedenza nel corso.
Ora è necessario aggiungere il codice per Awake() per inizializzare la variabile Instance:
/// <summary> /// Initialises this class /// </summary> private void Awake() { // Allows this instance to behave like a singleton Instance = this; }Eliminare i metodi Start() e Update().
Quindi, aggiungi la coroutine (con il metodo statico GetImageAsByteArray() sottostante), che otterrà i risultati dell'analisi dell'immagine acquisita dalla classe ImageCapture .
Nota
Nella coroutine AnalyseImageCapture , è presente una chiamata alla classe SceneOrganiser che deve ancora essere creata. Pertanto, lascia quelle righe commentate per ora.
/// <summary> /// Call the Computer Vision Service to submit the image. /// </summary> public IEnumerator AnalyseLastImageCaptured(string imagePath) { WWWForm webForm = new WWWForm(); using (UnityWebRequest unityWebRequest = UnityWebRequest.Post(predictionEndpoint, webForm)) { // Gets a byte array out of the saved image imageBytes = GetImageAsByteArray(imagePath); unityWebRequest.SetRequestHeader("Content-Type", "application/octet-stream"); unityWebRequest.SetRequestHeader("Prediction-Key", predictionKey); // The upload handler will help uploading the byte array with the request unityWebRequest.uploadHandler = new UploadHandlerRaw(imageBytes); unityWebRequest.uploadHandler.contentType = "application/octet-stream"; // The download handler will help receiving the analysis from Azure unityWebRequest.downloadHandler = new DownloadHandlerBuffer(); // Send the request yield return unityWebRequest.SendWebRequest(); string jsonResponse = unityWebRequest.downloadHandler.text; // The response will be in JSON format, therefore it needs to be deserialized // The following lines refers to a class that you will build in later Chapters // Wait until then to uncomment these lines //AnalysisObject analysisObject = new AnalysisObject(); //analysisObject = JsonConvert.DeserializeObject<AnalysisObject>(jsonResponse); //SceneOrganiser.Instance.SetTagsToLastLabel(analysisObject); } } /// <summary> /// Returns the contents of the specified image file as a byte array. /// </summary> static byte[] GetImageAsByteArray(string imageFilePath) { FileStream fileStream = new FileStream(imageFilePath, FileMode.Open, FileAccess.Read); BinaryReader binaryReader = new BinaryReader(fileStream); return binaryReader.ReadBytes((int)fileStream.Length); }Assicurarsi di salvare le modifiche in Visual Studio prima di tornare a Unity.
Capitolo 7 - Creare la classe CustomVisionObjects
La classe che verrà creata ora è la classe CustomVisionObjects .
Questo script contiene una serie di oggetti utilizzati da altre classi per serializzare e deserializzare le chiamate effettuate al servizio di Visione personalizzata.
Avviso
È importante prendere nota dell'endpoint fornito dal servizio Visione personalizzata, poiché la struttura JSON seguente è stata configurata per funzionare con la previsione della visione personalizzata v2.0. Se si dispone di una versione diversa, potrebbe essere necessario aggiornare la struttura seguente.
Per creare la classe:
Fare clic con il pulsante destro del mouse all'interno della cartella Script , quindi scegliere Crea>script C#. Chiama lo script CustomVisionObjects.
Fare doppio clic sul nuovo script CustomVisionObjects per aprirlo con Visual Studio.
Aggiungi i seguenti spazi dei nomi nella parte superiore del file:
using System; using System.Collections.Generic; using UnityEngine; using UnityEngine.Networking;Eliminare i metodi Start() e Update() all'interno della classe CustomVisionObjects ; Questa classe dovrebbe ora essere vuota.
Aggiungere le classi seguenti all'esterno della classe CustomVisionObjects . Questi oggetti vengono utilizzati dalla libreria Newtonsoft per serializzare e deserializzare i dati di risposta:
// The objects contained in this script represent the deserialized version // of the objects used by this application /// <summary> /// Web request object for image data /// </summary> class MultipartObject : IMultipartFormSection { public string sectionName { get; set; } public byte[] sectionData { get; set; } public string fileName { get; set; } public string contentType { get; set; } } /// <summary> /// JSON of all Tags existing within the project /// contains the list of Tags /// </summary> public class Tags_RootObject { public List<TagOfProject> Tags { get; set; } public int TotalTaggedImages { get; set; } public int TotalUntaggedImages { get; set; } } public class TagOfProject { public string Id { get; set; } public string Name { get; set; } public string Description { get; set; } public int ImageCount { get; set; } } /// <summary> /// JSON of Tag to associate to an image /// Contains a list of hosting the tags, /// since multiple tags can be associated with one image /// </summary> public class Tag_RootObject { public List<Tag> Tags { get; set; } } public class Tag { public string ImageId { get; set; } public string TagId { get; set; } } /// <summary> /// JSON of Images submitted /// Contains objects that host detailed information about one or more images /// </summary> public class ImageRootObject { public bool IsBatchSuccessful { get; set; } public List<SubmittedImage> Images { get; set; } } public class SubmittedImage { public string SourceUrl { get; set; } public string Status { get; set; } public ImageObject Image { get; set; } } public class ImageObject { public string Id { get; set; } public DateTime Created { get; set; } public int Width { get; set; } public int Height { get; set; } public string ImageUri { get; set; } public string ThumbnailUri { get; set; } } /// <summary> /// JSON of Service Iteration /// </summary> public class Iteration { public string Id { get; set; } public string Name { get; set; } public bool IsDefault { get; set; } public string Status { get; set; } public string Created { get; set; } public string LastModified { get; set; } public string TrainedAt { get; set; } public string ProjectId { get; set; } public bool Exportable { get; set; } public string DomainId { get; set; } } /// <summary> /// Predictions received by the Service after submitting an image for analysis /// </summary> [Serializable] public class AnalysisObject { public List<Prediction> Predictions { get; set; } } [Serializable] public class Prediction { public string TagName { get; set; } public double Probability { get; set; } }
Capitolo 8 - Creare la classe VoiceRecognizer
Questa classe riconoscerà l'input vocale dell'utente.
Per creare la classe:
Fare clic con il pulsante destro del mouse all'interno della cartella Script , quindi scegliere Crea>script C#. Chiama lo script VoiceRecognizer.
Fare doppio clic sul nuovo script VoiceRecognizer per aprirlo con Visual Studio.
Aggiungi i seguenti spazi dei nomi sopra la classe VoiceRecognizer :
using System; using System.Collections.Generic; using System.Linq; using UnityEngine; using UnityEngine.Windows.Speech;Aggiungi quindi le seguenti variabili all'interno della classe VoiceRecognizer, sopra il metodo Start():
/// <summary> /// Allows this class to behave like a singleton /// </summary> public static VoiceRecognizer Instance; /// <summary> /// Recognizer class for voice recognition /// </summary> internal KeywordRecognizer keywordRecognizer; /// <summary> /// List of Keywords registered /// </summary> private Dictionary<string, Action> _keywords = new Dictionary<string, Action>();Aggiungere i metodi Awake() e Start(), l'ultimo dei quali imposterà le parole chiave dell'utente da riconoscere quando si associa un tag a un'immagine:
/// <summary> /// Called on initialization /// </summary> private void Awake() { Instance = this; } /// <summary> /// Runs at initialization right after Awake method /// </summary> void Start () { Array tagsArray = Enum.GetValues(typeof(CustomVisionTrainer.Tags)); foreach (object tagWord in tagsArray) { _keywords.Add(tagWord.ToString(), () => { // When a word is recognized, the following line will be called CustomVisionTrainer.Instance.VerifyTag(tagWord.ToString()); }); } _keywords.Add("Discard", () => { // When a word is recognized, the following line will be called // The user does not want to submit the image // therefore ignore and discard the process ImageCapture.Instance.ResetImageCapture(); keywordRecognizer.Stop(); }); //Create the keyword recognizer keywordRecognizer = new KeywordRecognizer(_keywords.Keys.ToArray()); // Register for the OnPhraseRecognized event keywordRecognizer.OnPhraseRecognized += KeywordRecognizer_OnPhraseRecognized; }Eliminare il metodo Update().
Aggiungere il gestore seguente, che viene chiamato ogni volta che viene riconosciuto l'input vocale:
/// <summary> /// Handler called when a word is recognized /// </summary> private void KeywordRecognizer_OnPhraseRecognized(PhraseRecognizedEventArgs args) { Action keywordAction; // if the keyword recognized is in our dictionary, call that Action. if (_keywords.TryGetValue(args.text, out keywordAction)) { keywordAction.Invoke(); } }Assicurarsi di salvare le modifiche in Visual Studio prima di tornare a Unity.
Nota
Non preoccuparti del codice che potrebbe sembrare avere un errore, poiché presto fornirai altre classi, che li risolveranno.
Capitolo 9 - Creare la classe CustomVisionTrainer
Questa classe concatena una serie di chiamate Web per eseguire il training del servizio di Visione personalizzata. Ogni chiamata verrà spiegata in dettaglio sopra il codice.
Per creare la classe:
Fare clic con il pulsante destro del mouse all'interno della cartella Script , quindi scegliere Crea>script C#. Chiamare lo script CustomVisionTrainer.
Fare doppio clic sul nuovo script CustomVisionTrainer per aprirlo con Visual Studio.
Aggiungere i seguenti spazi dei nomi sopra la classe CustomVisionTrainer :
using Newtonsoft.Json; using System.Collections; using System.Collections.Generic; using System.IO; using System.Text; using UnityEngine; using UnityEngine.Networking;Aggiungi quindi le seguenti variabili all'interno della classe CustomVisionTrainer, sopra il metodo Start().
Nota
L'URL di formazione utilizzato qui è fornito nella documentazione di Visione personalizzata Training 1.2 e ha una struttura di:https://southcentralus.api.cognitive.microsoft.com/customvision/v1.2/Training/projects/{projectId}/
Per altre informazioni, visita l'API di riferimento di Visione personalizzata Training v1.2.Avviso
È importante prendere nota dell'endpoint fornito dal servizio Visione personalizzata per la modalità di addestramento, poiché la struttura JSON usata (all'interno della classe CustomVisionObjects) è stata configurata per funzionare con l'addestramento sulla Visione personalizzata v1.2. Se si dispone di una versione diversa, potrebbe essere necessario aggiornare la struttura degli oggetti .
/// <summary> /// Allows this class to behave like a singleton /// </summary> public static CustomVisionTrainer Instance; /// <summary> /// Custom Vision Service URL root /// </summary> private string url = "https://southcentralus.api.cognitive.microsoft.com/customvision/v1.2/Training/projects/"; /// <summary> /// Insert your prediction key here /// </summary> private string trainingKey = "- Insert your key here -"; /// <summary> /// Insert your Project Id here /// </summary> private string projectId = "- Insert your Project Id here -"; /// <summary> /// Byte array of the image to submit for analysis /// </summary> internal byte[] imageBytes; /// <summary> /// The Tags accepted /// </summary> internal enum Tags {Mouse, Keyboard} /// <summary> /// The UI displaying the training Chapters /// </summary> private TextMesh trainingUI_TextMesh;Importante
Assicurarsi di aggiungere il valore della chiave di servizio (chiave di training) e il valore dell'ID progetto, che hai annotato in precedenza; questi sono i valori raccolti dal portale all'inizio del corso (Capitolo 2, passaggio 10 in poi).
Aggiungere i seguenti metodi Start() e Awake(). Questi metodi vengono chiamati all'inizializzazione e contengono la chiamata per configurare l'interfaccia utente:
/// <summary> /// Called on initialization /// </summary> private void Awake() { Instance = this; } /// <summary> /// Runs at initialization right after Awake method /// </summary> private void Start() { trainingUI_TextMesh = SceneOrganiser.Instance.CreateTrainingUI("TrainingUI", 0.04f, 0, 4, false); }Eliminare il metodo Update(). Questa classe non ne avrà bisogno.
Aggiungi il metodo RequestTagSelection(). Questo metodo è il primo ad essere chiamato quando un'immagine è stata acquisita e memorizzata nel dispositivo ed è ora pronta per essere inviata al Servizio di Visione personalizzata, per addestrarla. Questo metodo visualizza, nell'interfaccia utente di training, un set di parole chiave che l'utente può utilizzare per contrassegnare l'immagine acquisita. Avvisa anche la classe VoiceRecognizer di iniziare ad ascoltare l'utente per l'input vocale.
internal void RequestTagSelection() { trainingUI_TextMesh.gameObject.SetActive(true); trainingUI_TextMesh.text = $" \nUse voice command \nto choose between the following tags: \nMouse\nKeyboard \nor say Discard"; VoiceRecognizer.Instance.keywordRecognizer.Start(); }Aggiungi il metodo VerifyTag(). Questo metodo riceverà l'input vocale riconosciuto dalla classe VoiceRecognizer e ne verificherà la validità, quindi inizierà il processo di training.
/// <summary> /// Verify voice input against stored tags. /// If positive, it will begin the Service training process. /// </summary> internal void VerifyTag(string spokenTag) { if (spokenTag == Tags.Mouse.ToString() || spokenTag == Tags.Keyboard.ToString()) { trainingUI_TextMesh.text = $"Tag chosen: {spokenTag}"; VoiceRecognizer.Instance.keywordRecognizer.Stop(); StartCoroutine(SubmitImageForTraining(ImageCapture.Instance.filePath, spokenTag)); } }Aggiungi il metodo SubmitImageForTraining(). Questo metodo inizierà il processo di formazione sul servizio di Visione personalizzata. Il primo passaggio consiste nel recuperare l'ID tag dal servizio associato all'input vocale convalidato dall'utente. L'ID tag verrà quindi caricato insieme all'immagine.
/// <summary> /// Call the Custom Vision Service to submit the image. /// </summary> public IEnumerator SubmitImageForTraining(string imagePath, string tag) { yield return new WaitForSeconds(2); trainingUI_TextMesh.text = $"Submitting Image \nwith tag: {tag} \nto Custom Vision Service"; string imageId = string.Empty; string tagId = string.Empty; // Retrieving the Tag Id relative to the voice input string getTagIdEndpoint = string.Format("{0}{1}/tags", url, projectId); using (UnityWebRequest www = UnityWebRequest.Get(getTagIdEndpoint)) { www.SetRequestHeader("Training-Key", trainingKey); www.downloadHandler = new DownloadHandlerBuffer(); yield return www.SendWebRequest(); string jsonResponse = www.downloadHandler.text; Tags_RootObject tagRootObject = JsonConvert.DeserializeObject<Tags_RootObject>(jsonResponse); foreach (TagOfProject tOP in tagRootObject.Tags) { if (tOP.Name == tag) { tagId = tOP.Id; } } } // Creating the image object to send for training List<IMultipartFormSection> multipartList = new List<IMultipartFormSection>(); MultipartObject multipartObject = new MultipartObject(); multipartObject.contentType = "application/octet-stream"; multipartObject.fileName = ""; multipartObject.sectionData = GetImageAsByteArray(imagePath); multipartList.Add(multipartObject); string createImageFromDataEndpoint = string.Format("{0}{1}/images?tagIds={2}", url, projectId, tagId); using (UnityWebRequest www = UnityWebRequest.Post(createImageFromDataEndpoint, multipartList)) { // Gets a byte array out of the saved image imageBytes = GetImageAsByteArray(imagePath); //unityWebRequest.SetRequestHeader("Content-Type", "application/octet-stream"); www.SetRequestHeader("Training-Key", trainingKey); // The upload handler will help uploading the byte array with the request www.uploadHandler = new UploadHandlerRaw(imageBytes); // The download handler will help receiving the analysis from Azure www.downloadHandler = new DownloadHandlerBuffer(); // Send the request yield return www.SendWebRequest(); string jsonResponse = www.downloadHandler.text; ImageRootObject m = JsonConvert.DeserializeObject<ImageRootObject>(jsonResponse); imageId = m.Images[0].Image.Id; } trainingUI_TextMesh.text = "Image uploaded"; StartCoroutine(TrainCustomVisionProject()); }Aggiungi il metodo TrainCustomVisionProject(). Una volta che l'immagine è stata inviata e contrassegnata, questo metodo verrà chiamato. Verrà creata una nuova iterazione che verrà addestrata con tutte le immagini precedenti inviate al servizio più l'immagine appena caricata. Una volta completato il training, questo metodo chiamerà un metodo per impostare l'iterazione appena creata come predefinita, in modo che l'endpoint usato per l'analisi sia l'ultima iterazione con training.
/// <summary> /// Call the Custom Vision Service to train the Service. /// It will generate a new Iteration in the Service /// </summary> public IEnumerator TrainCustomVisionProject() { yield return new WaitForSeconds(2); trainingUI_TextMesh.text = "Training Custom Vision Service"; WWWForm webForm = new WWWForm(); string trainProjectEndpoint = string.Format("{0}{1}/train", url, projectId); using (UnityWebRequest www = UnityWebRequest.Post(trainProjectEndpoint, webForm)) { www.SetRequestHeader("Training-Key", trainingKey); www.downloadHandler = new DownloadHandlerBuffer(); yield return www.SendWebRequest(); string jsonResponse = www.downloadHandler.text; Debug.Log($"Training - JSON Response: {jsonResponse}"); // A new iteration that has just been created and trained Iteration iteration = new Iteration(); iteration = JsonConvert.DeserializeObject<Iteration>(jsonResponse); if (www.isDone) { trainingUI_TextMesh.text = "Custom Vision Trained"; // Since the Service has a limited number of iterations available, // we need to set the last trained iteration as default // and delete all the iterations you dont need anymore StartCoroutine(SetDefaultIteration(iteration)); } } }Aggiungi il metodo SetDefaultIteration(). Questo metodo imposterà l'iterazione creata e addestrata in precedenza come predefinita. Una volta completato, questo metodo dovrà eliminare l'iterazione precedente esistente nel servizio. Al momento della stesura di questo corso, è previsto un limite massimo di dieci (10) iterazioni consentite contemporaneamente nel Servizio.
/// <summary> /// Set the newly created iteration as Default /// </summary> private IEnumerator SetDefaultIteration(Iteration iteration) { yield return new WaitForSeconds(5); trainingUI_TextMesh.text = "Setting default iteration"; // Set the last trained iteration to default iteration.IsDefault = true; // Convert the iteration object as JSON string iterationAsJson = JsonConvert.SerializeObject(iteration); byte[] bytes = Encoding.UTF8.GetBytes(iterationAsJson); string setDefaultIterationEndpoint = string.Format("{0}{1}/iterations/{2}", url, projectId, iteration.Id); using (UnityWebRequest www = UnityWebRequest.Put(setDefaultIterationEndpoint, bytes)) { www.method = "PATCH"; www.SetRequestHeader("Training-Key", trainingKey); www.SetRequestHeader("Content-Type", "application/json"); www.downloadHandler = new DownloadHandlerBuffer(); yield return www.SendWebRequest(); string jsonResponse = www.downloadHandler.text; if (www.isDone) { trainingUI_TextMesh.text = "Default iteration is set \nDeleting Unused Iteration"; StartCoroutine(DeletePreviousIteration(iteration)); } } }Aggiungi il metodo DeletePreviousIteration(). Questo metodo troverà ed eliminerà l'iterazione non predefinita precedente:
/// <summary> /// Delete the previous non-default iteration. /// </summary> public IEnumerator DeletePreviousIteration(Iteration iteration) { yield return new WaitForSeconds(5); trainingUI_TextMesh.text = "Deleting Unused \nIteration"; string iterationToDeleteId = string.Empty; string findAllIterationsEndpoint = string.Format("{0}{1}/iterations", url, projectId); using (UnityWebRequest www = UnityWebRequest.Get(findAllIterationsEndpoint)) { www.SetRequestHeader("Training-Key", trainingKey); www.downloadHandler = new DownloadHandlerBuffer(); yield return www.SendWebRequest(); string jsonResponse = www.downloadHandler.text; // The iteration that has just been trained List<Iteration> iterationsList = new List<Iteration>(); iterationsList = JsonConvert.DeserializeObject<List<Iteration>>(jsonResponse); foreach (Iteration i in iterationsList) { if (i.IsDefault != true) { Debug.Log($"Cleaning - Deleting iteration: {i.Name}, {i.Id}"); iterationToDeleteId = i.Id; break; } } } string deleteEndpoint = string.Format("{0}{1}/iterations/{2}", url, projectId, iterationToDeleteId); using (UnityWebRequest www2 = UnityWebRequest.Delete(deleteEndpoint)) { www2.SetRequestHeader("Training-Key", trainingKey); www2.downloadHandler = new DownloadHandlerBuffer(); yield return www2.SendWebRequest(); string jsonResponse = www2.downloadHandler.text; trainingUI_TextMesh.text = "Iteration Deleted"; yield return new WaitForSeconds(2); trainingUI_TextMesh.text = "Ready for next \ncapture"; yield return new WaitForSeconds(2); trainingUI_TextMesh.text = ""; ImageCapture.Instance.ResetImageCapture(); } }L'ultimo metodo da aggiungere in questa classe è il metodo GetImageAsByteArray(), utilizzato nelle chiamate Web per convertire l'immagine acquisita in una matrice di byte.
/// <summary> /// Returns the contents of the specified image file as a byte array. /// </summary> static byte[] GetImageAsByteArray(string imageFilePath) { FileStream fileStream = new FileStream(imageFilePath, FileMode.Open, FileAccess.Read); BinaryReader binaryReader = new BinaryReader(fileStream); return binaryReader.ReadBytes((int)fileStream.Length); }Assicurarsi di salvare le modifiche in Visual Studio prima di tornare a Unity.
Capitolo 10 - Creare la classe SceneOrganiser
Questa classe:
Crea un oggetto cursore da collegare alla fotocamera principale.
Creare un oggetto Label che verrà visualizzato quando il servizio riconosce gli oggetti del mondo reale.
Configura la fotocamera principale collegandovi i componenti appropriati.
Quando sei in modalità Analisi, genera le etichette in fase di esecuzione, nello spazio del mondo appropriato rispetto alla posizione della fotocamera principale e visualizza i dati ricevuti dal servizio di Visione personalizzata.
In modalità Allenamento, genera l'interfaccia utente che mostrerà le diverse fasi del processo di addestramento.
Per creare la classe:
Fare clic con il pulsante destro del mouse all'interno della cartella Script , quindi scegliere Crea>script C#. Assegna un nome allo script SceneOrganizer.
Fare doppio clic sul nuovo script SceneOrganiser per aprirlo con Visual Studio.
Avrai bisogno di un solo spazio dei nomi, rimuovi gli altri da sopra la classe SceneOrganiser :
using UnityEngine;Quindi aggiungi le seguenti variabili all'interno della classe SceneOrganiser, sopra il metodo Start():
/// <summary> /// Allows this class to behave like a singleton /// </summary> public static SceneOrganiser Instance; /// <summary> /// The cursor object attached to the camera /// </summary> internal GameObject cursor; /// <summary> /// The label used to display the analysis on the objects in the real world /// </summary> internal GameObject label; /// <summary> /// Object providing the current status of the camera. /// </summary> internal TextMesh cameraStatusIndicator; /// <summary> /// Reference to the last label positioned /// </summary> internal Transform lastLabelPlaced; /// <summary> /// Reference to the last label positioned /// </summary> internal TextMesh lastLabelPlacedText; /// <summary> /// Current threshold accepted for displaying the label /// Reduce this value to display the recognition more often /// </summary> internal float probabilityThreshold = 0.5f;Eliminare i metodi Start() e Update().
Subito sotto le variabili, aggiungete il metodo Awake(), che inizializzerà la classe e imposterà la scena.
/// <summary> /// Called on initialization /// </summary> private void Awake() { // Use this class instance as singleton Instance = this; // Add the ImageCapture class to this GameObject gameObject.AddComponent<ImageCapture>(); // Add the CustomVisionAnalyser class to this GameObject gameObject.AddComponent<CustomVisionAnalyser>(); // Add the CustomVisionTrainer class to this GameObject gameObject.AddComponent<CustomVisionTrainer>(); // Add the VoiceRecogniser class to this GameObject gameObject.AddComponent<VoiceRecognizer>(); // Add the CustomVisionObjects class to this GameObject gameObject.AddComponent<CustomVisionObjects>(); // Create the camera Cursor cursor = CreateCameraCursor(); // Load the label prefab as reference label = CreateLabel(); // Create the camera status indicator label, and place it above where predictions // and training UI will appear. cameraStatusIndicator = CreateTrainingUI("Status Indicator", 0.02f, 0.2f, 3, true); // Set camera status indicator to loading. SetCameraStatus("Loading"); }Ora aggiungi il metodo CreateCameraCursor() che crea e posiziona il cursore della fotocamera principale e il metodo CreateLabel(), che crea l'oggetto Etichetta di analisi .
/// <summary> /// Spawns cursor for the Main Camera /// </summary> private GameObject CreateCameraCursor() { // Create a sphere as new cursor GameObject newCursor = GameObject.CreatePrimitive(PrimitiveType.Sphere); // Attach it to the camera newCursor.transform.parent = gameObject.transform; // Resize the new cursor newCursor.transform.localScale = new Vector3(0.02f, 0.02f, 0.02f); // Move it to the correct position newCursor.transform.localPosition = new Vector3(0, 0, 4); // Set the cursor color to red newCursor.GetComponent<Renderer>().material = new Material(Shader.Find("Diffuse")); newCursor.GetComponent<Renderer>().material.color = Color.green; return newCursor; } /// <summary> /// Create the analysis label object /// </summary> private GameObject CreateLabel() { // Create a sphere as new cursor GameObject newLabel = new GameObject(); // Resize the new cursor newLabel.transform.localScale = new Vector3(0.01f, 0.01f, 0.01f); // Creating the text of the label TextMesh t = newLabel.AddComponent<TextMesh>(); t.anchor = TextAnchor.MiddleCenter; t.alignment = TextAlignment.Center; t.fontSize = 50; t.text = ""; return newLabel; }Aggiungi il metodo SetCameraStatus(), che gestirà i messaggi destinati alla mesh di testo fornendo lo stato della fotocamera.
/// <summary> /// Set the camera status to a provided string. Will be coloured if it matches a keyword. /// </summary> /// <param name="statusText">Input string</param> public void SetCameraStatus(string statusText) { if (string.IsNullOrEmpty(statusText) == false) { string message = "white"; switch (statusText.ToLower()) { case "loading": message = "yellow"; break; case "ready": message = "green"; break; case "uploading image": message = "red"; break; case "looping capture": message = "yellow"; break; case "analysis": message = "red"; break; } cameraStatusIndicator.GetComponent<TextMesh>().text = $"Camera Status:\n<color={message}>{statusText}..</color>"; } }Aggiungere i metodi PlaceAnalysisLabel() e SetTagsToLastLabel(), che genereranno e visualizzeranno i dati dal servizio di Visione personalizzata nella scena.
/// <summary> /// Instantiate a label in the appropriate location relative to the Main Camera. /// </summary> public void PlaceAnalysisLabel() { lastLabelPlaced = Instantiate(label.transform, cursor.transform.position, transform.rotation); lastLabelPlacedText = lastLabelPlaced.GetComponent<TextMesh>(); } /// <summary> /// Set the Tags as Text of the last label created. /// </summary> public void SetTagsToLastLabel(AnalysisObject analysisObject) { lastLabelPlacedText = lastLabelPlaced.GetComponent<TextMesh>(); if (analysisObject.Predictions != null) { foreach (Prediction p in analysisObject.Predictions) { if (p.Probability > 0.02) { lastLabelPlacedText.text += $"Detected: {p.TagName} {p.Probability.ToString("0.00 \n")}"; Debug.Log($"Detected: {p.TagName} {p.Probability.ToString("0.00 \n")}"); } } } }Infine, aggiungere il metodo CreateTrainingUI(), che genererà l'interfaccia utente che mostra le molteplici fasi del processo di training quando l'applicazione è in modalità di training. Questo metodo verrà sfruttato anche per creare l'oggetto di stato della fotocamera.
/// <summary> /// Create a 3D Text Mesh in scene, with various parameters. /// </summary> /// <param name="name">name of object</param> /// <param name="scale">scale of object (i.e. 0.04f)</param> /// <param name="yPos">height above the cursor (i.e. 0.3f</param> /// <param name="zPos">distance from the camera</param> /// <param name="setActive">whether the text mesh should be visible when it has been created</param> /// <returns>Returns a 3D text mesh within the scene</returns> internal TextMesh CreateTrainingUI(string name, float scale, float yPos, float zPos, bool setActive) { GameObject display = new GameObject(name, typeof(TextMesh)); display.transform.parent = Camera.main.transform; display.transform.localPosition = new Vector3(0, yPos, zPos); display.SetActive(setActive); display.transform.localScale = new Vector3(scale, scale, scale); display.transform.rotation = new Quaternion(); TextMesh textMesh = display.GetComponent<TextMesh>(); textMesh.anchor = TextAnchor.MiddleCenter; textMesh.alignment = TextAlignment.Center; return textMesh; }Assicurarsi di salvare le modifiche in Visual Studio prima di tornare a Unity.
Importante
Prima di continuare, aprire la classe CustomVisionAnalyser e, all'interno del metodo AnalyseLastImageCaptured(),decommentare le righe seguenti:
AnalysisObject analysisObject = new AnalysisObject();
analysisObject = JsonConvert.DeserializeObject<AnalysisObject>(jsonResponse);
SceneOrganiser.Instance.SetTagsToLastLabel(analysisObject);
Capitolo 11 - Creare la classe ImageCapture
La prossima classe che verrà creata è la classe ImageCapture .
Questa classe si occupa di:
Acquisizione di un'immagine con la fotocamera HoloLens e archiviazione nella cartella dell'app .
Utilizzo Movimenti di tocco dell'utente.
Mantenimento del valore di enumerazione che determina se l'applicazione verrà eseguita in modalità analisi o training .
Per creare la classe:
Passare alla cartella Script creata in precedenza.
Fare clic con il pulsante destro del mouse all'interno della cartella, quindi scegliere Crea > script C#. Assegna un nome allo script ImageCapture.
Fare doppio clic sul nuovo script ImageCapture per aprirlo con Visual Studio.
Sostituisci gli spazi dei nomi nella parte superiore del file con quanto segue:
using System; using System.IO; using System.Linq; using UnityEngine; using UnityEngine.XR.WSA.Input; using UnityEngine.XR.WSA.WebCam;Quindi aggiungi le seguenti variabili all'interno della classe ImageCapture, sopra il metodo Start():
/// <summary> /// Allows this class to behave like a singleton /// </summary> public static ImageCapture Instance; /// <summary> /// Keep counts of the taps for image renaming /// </summary> private int captureCount = 0; /// <summary> /// Photo Capture object /// </summary> private PhotoCapture photoCaptureObject = null; /// <summary> /// Allows gestures recognition in HoloLens /// </summary> private GestureRecognizer recognizer; /// <summary> /// Loop timer /// </summary> private float secondsBetweenCaptures = 10f; /// <summary> /// Application main functionalities switch /// </summary> internal enum AppModes {Analysis, Training } /// <summary> /// Local variable for current AppMode /// </summary> internal AppModes AppMode { get; private set; } /// <summary> /// Flagging if the capture loop is running /// </summary> internal bool captureIsActive; /// <summary> /// File path of current analysed photo /// </summary> internal string filePath = string.Empty;Ora è necessario aggiungere il codice per i metodi Awake() e Start():
/// <summary> /// Called on initialization /// </summary> private void Awake() { Instance = this; // Change this flag to switch between Analysis Mode and Training Mode AppMode = AppModes.Training; } /// <summary> /// Runs at initialization right after Awake method /// </summary> void Start() { // Clean up the LocalState folder of this application from all photos stored DirectoryInfo info = new DirectoryInfo(Application.persistentDataPath); var fileInfo = info.GetFiles(); foreach (var file in fileInfo) { try { file.Delete(); } catch (Exception) { Debug.LogFormat("Cannot delete file: ", file.Name); } } // Subscribing to the HoloLens API gesture recognizer to track user gestures recognizer = new GestureRecognizer(); recognizer.SetRecognizableGestures(GestureSettings.Tap); recognizer.Tapped += TapHandler; recognizer.StartCapturingGestures(); SceneOrganiser.Instance.SetCameraStatus("Ready"); }Implementa un gestore che verrà chiamato quando si verifica un movimento Tocco.
/// <summary> /// Respond to Tap Input. /// </summary> private void TapHandler(TappedEventArgs obj) { switch (AppMode) { case AppModes.Analysis: if (!captureIsActive) { captureIsActive = true; // Set the cursor color to red SceneOrganiser.Instance.cursor.GetComponent<Renderer>().material.color = Color.red; // Update camera status to looping capture. SceneOrganiser.Instance.SetCameraStatus("Looping Capture"); // Begin the capture loop InvokeRepeating("ExecuteImageCaptureAndAnalysis", 0, secondsBetweenCaptures); } else { // The user tapped while the app was analyzing // therefore stop the analysis process ResetImageCapture(); } break; case AppModes.Training: if (!captureIsActive) { captureIsActive = true; // Call the image capture ExecuteImageCaptureAndAnalysis(); // Set the cursor color to red SceneOrganiser.Instance.cursor.GetComponent<Renderer>().material.color = Color.red; // Update camera status to uploading image. SceneOrganiser.Instance.SetCameraStatus("Uploading Image"); } break; } }Nota
In modalità di analisi il metodo TapHandler funge da interruttore per avviare o arrestare il ciclo di acquisizione foto.
In modalità Allenamento , acquisirà un'immagine dalla fotocamera.
Quando il cursore è verde, significa che la fotocamera è disponibile per acquisire l'immagine.
Quando il cursore è rosso, la fotocamera è occupata.
Aggiungere il metodo usato dall'applicazione per avviare il processo di acquisizione delle immagini e archiviare l'immagine.
/// <summary> /// Begin process of Image Capturing and send To Azure Custom Vision Service. /// </summary> private void ExecuteImageCaptureAndAnalysis() { // Update camera status to analysis. SceneOrganiser.Instance.SetCameraStatus("Analysis"); // Create a label in world space using the SceneOrganiser class // Invisible at this point but correctly positioned where the image was taken SceneOrganiser.Instance.PlaceAnalysisLabel(); // Set the camera resolution to be the highest possible Resolution cameraResolution = PhotoCapture.SupportedResolutions.OrderByDescending((res) => res.width * res.height).First(); Texture2D targetTexture = new Texture2D(cameraResolution.width, cameraResolution.height); // Begin capture process, set the image format PhotoCapture.CreateAsync(false, delegate (PhotoCapture captureObject) { photoCaptureObject = captureObject; CameraParameters camParameters = new CameraParameters { hologramOpacity = 0.0f, cameraResolutionWidth = targetTexture.width, cameraResolutionHeight = targetTexture.height, pixelFormat = CapturePixelFormat.BGRA32 }; // Capture the image from the camera and save it in the App internal folder captureObject.StartPhotoModeAsync(camParameters, delegate (PhotoCapture.PhotoCaptureResult result) { string filename = string.Format(@"CapturedImage{0}.jpg", captureCount); filePath = Path.Combine(Application.persistentDataPath, filename); captureCount++; photoCaptureObject.TakePhotoAsync(filePath, PhotoCaptureFileOutputFormat.JPG, OnCapturedPhotoToDisk); }); }); }Aggiungi i gestori che verranno chiamati quando la foto è stata acquisita e per quando è pronta per essere analizzata. Il risultato viene quindi passato al CustomVisionAnalyser o al CustomVisionTrainer a seconda della modalità su cui è impostato il codice.
/// <summary> /// Register the full execution of the Photo Capture. /// </summary> void OnCapturedPhotoToDisk(PhotoCapture.PhotoCaptureResult result) { // Call StopPhotoMode once the image has successfully captured photoCaptureObject.StopPhotoModeAsync(OnStoppedPhotoMode); } /// <summary> /// The camera photo mode has stopped after the capture. /// Begin the Image Analysis process. /// </summary> void OnStoppedPhotoMode(PhotoCapture.PhotoCaptureResult result) { Debug.LogFormat("Stopped Photo Mode"); // Dispose from the object in memory and request the image analysis photoCaptureObject.Dispose(); photoCaptureObject = null; switch (AppMode) { case AppModes.Analysis: // Call the image analysis StartCoroutine(CustomVisionAnalyser.Instance.AnalyseLastImageCaptured(filePath)); break; case AppModes.Training: // Call training using captured image CustomVisionTrainer.Instance.RequestTagSelection(); break; } } /// <summary> /// Stops all capture pending actions /// </summary> internal void ResetImageCapture() { captureIsActive = false; // Set the cursor color to green SceneOrganiser.Instance.cursor.GetComponent<Renderer>().material.color = Color.green; // Update camera status to ready. SceneOrganiser.Instance.SetCameraStatus("Ready"); // Stop the capture loop if active CancelInvoke(); }Assicurarsi di salvare le modifiche in Visual Studio prima di tornare a Unity.
Ora che tutti gli script sono stati completati, torna nell'Editor Unity, quindi fai clic e trascina la classe SceneOrganiser dalla cartella Scripts all'oggetto Fotocamera principale nel pannello Gerarchia.
Capitolo 12 - Prima di costruire
Per eseguire un test approfondito dell'applicazione, dovrai trasferirla localmente sul tuo dispositivo HoloLens.
Prima di farlo, assicurati che:
Tutte le impostazioni menzionate nel Capitolo 2 sono impostate correttamente.
Tutti i campi nella Videocamera principale, Pannello Controllo, sono assegnati correttamente.
Lo script SceneOrganiser è collegato all'oggetto Videocamera principale .
Assicurarsi di inserire la chiave di completamento nella variabile predictionKey .
L'endpoint di previsione è stato inserito nella variabile predictionEndpoint .
Hai inserito la tua chiave di allenamento nella variabile trainingKey , della classe CustomVisionTrainer .
L'ID progetto è stato inserito nella variabile projectId della classe CustomVisionTrainer.
Capitolo 13 - Compilare e trasferire localmente l'applicazione
Per iniziare il processo di compilazione :
Passare a Impostazioni compilazione file>.
Spuntare i progetti C# di Unity.
Fai clic su Crea. Unity avvierà una finestra Esplora file, in cui è necessario creare e selezionare una cartella in cui compilare l'app. Crea subito quella cartella e denominala App. Quindi, con la cartella dell'app selezionata, fai clic su Seleziona cartella.
Unity inizierà a compilare il progetto nella cartella App .
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 avviserà l'aggiunta di una nuova finestra).
Per eseguire la distribuzione in HoloLens:
Avrai bisogno dell'indirizzo IP del tuo HoloLens (per la distribuzione remota) e per assicurarti che il tuo HoloLens sia in modalità sviluppatore. Procedura:
Mentre indossi HoloLens, apri le Impostazioni.
Vai alleopzioni avanzatedi rete & Internet>Wi-Fi>
Prendere nota dell'indirizzo IPv4 .
Torna quindi a Impostazioni e quindi ad Aggiorna & sicurezza>per gli sviluppatori
Attivare la modalità sviluppatore.
Passa alla nuova build di Unity (la cartella App ) e apri il file della soluzione con Visual Studio.
In Configurazione soluzione , selezionare Debug.
In Piattaforma soluzione selezionare x86, Computer remoto. Ti verrà chiesto di inserire l'indirizzo IP di un dispositivo remoto (HoloLens, in questo caso, come hai indicato).
Vai al menu Crea e fai clic su Distribuisci soluzione per trasferire localmente l'applicazione nel tuo dispositivo HoloLens.
L'app dovrebbe ora essere visualizzata nell'elenco delle app installate in HoloLens, pronte per essere avviate.
Nota
Per eseguire la distribuzione nell'headset immersivo, imposta la piattaforma della soluzione su Computer locale e imposta la configurazione su Debug, con x86 come piattaforma. Quindi eseguire la distribuzione sul computer locale, utilizzando la voce di menu Compila , selezionando Distribuisci soluzione.
Per utilizzare l'applicazione
Per cambiare la funzionalità dell'app tra la modalità Training e la modalità Prediction , è necessario aggiornare la variabile AppMode , che si trova nel metodo Awake() all'interno della classe ImageCapture .
// Change this flag to switch between Analysis mode and Training mode
AppMode = AppModes.Training;
o
// Change this flag to switch between Analysis mode and Training mode
AppMode = AppModes.Analysis;
In modalità Allenamento :
Guarda il mouse o la tastiera e usa il gesto Tocco.
Successivamente, apparirà un testo che ti chiederà di fornire un tag.
Pronuncia mouse otastiera.
In modalità di previsione :
Guardare un oggetto e usare il gesto Tocco.
Apparirà il testo che fornisce l'oggetto rilevato, con la più alta probabilità (questo è normalizzato).
Capitolo 14 - Valutare e migliorare il modello di Visione personalizzata
Per rendere il servizio più accurato, sarà necessario continuare a eseguire il training del modello usato per la previsione. Ciò si ottiene utilizzando la nuova applicazione, con entrambe le modalità di addestramento e di previsione , con quest'ultima che richiede di visitare il portale, che è ciò che è trattato in questo capitolo. Preparati a rivisitare il tuo portale molte volte, per migliorare continuamente il tuo modello.
Vai di nuovo al tuo portale Azure Visione personalizzata e, una volta che sei nel tuo progetto, seleziona la scheda Pronostici (in alto al centro della pagina):
Verranno visualizzate tutte le immagini inviate al servizio durante l'esecuzione dell'applicazione. Se passi il mouse sulle immagini, ti forniranno le previsioni fatte per quell'immagine:
Selezionare una delle immagini per aprirla. Una volta aperta, vedrai le previsioni fatte per quell'immagine a destra. Se le previsioni erano corrette e si desidera aggiungere questa immagine al modello di addestramento del servizio, fare clic sulla casella di input Tag personali e selezionare il tag che si desidera associare. Al termine, fare clic sul pulsante Salva e chiudi in basso a destra e passare all'immagine successiva.
Una volta tornati alla griglia di immagini, noterai che le immagini a cui hai aggiunto tag (e salvato), verranno rimosse. Se trovi delle immagini che ritieni non abbiano il tuo elemento taggato al loro interno, puoi eliminarle, facendo clic sul segno di spunta su quell'immagine (puoi farlo per diverse immagini) e quindi facendo clic su Elimina nell'angolo in alto a destra della pagina della griglia. Nel popup seguente è possibile fare clic su Sì, Elimina o No, rispettivamente per confermare l'eliminazione o annullarla.
Quando sei pronto per procedere, fai clic sul pulsante verde Treno in alto a destra. Il modello di servizio verrà addestrato con tutte le immagini fornite (che lo renderanno più accurato). Una volta completata la formazione, assicurati di fare di nuovo clic sul pulsante Rendi predefinito , in modo che l'URL di previsione continui a utilizzare l'iterazione più aggiornata del servizio.
L'applicazione API Visione personalizzata finita
Congratulazioni, hai creato un'app di realtà mista che sfrutta l'API Azure Visione personalizzata per riconoscere gli oggetti del mondo reale, addestrare il modello di servizio e mostrare la sicurezza di ciò che è stato visto.
Esercizi bonus
Esercizio 1
Addestra il tuo servizio di Visione personalizzata a riconoscere più oggetti.
Esercizio 2
Per approfondire ciò che hai appreso, completa i seguenti esercizi:
Riprodurre un suono quando viene riconosciuto un oggetto.
Esercizio 3
Usare l'API per rieseguire il training del servizio con le stesse immagini analizzate dall'app, in modo da rendere il servizio più accurato (eseguire contemporaneamente la previsione e l'addestramento).