Hinweis
Für den Zugriff auf diese Seite ist eine Autorisierung erforderlich. Sie können versuchen, sich anzumelden oder das Verzeichnis zu wechseln.
Für den Zugriff auf diese Seite ist eine Autorisierung erforderlich. Sie können versuchen, das Verzeichnis zu wechseln.
Hinweis
Die Tutorials der Mixed Reality Academy wurden mit Blick auf HoloLens (1. Generation) und immersive Mixed Reality-Headsets entwickelt. Daher halten wir es für wichtig, diese Tutorials für Entwickler beizubehalten, die noch nach Anleitungen bei der Entwicklung für diese Geräte suchen. Diese Tutorials werden nicht mit den neuesten Toolsets oder Interaktionen aktualisiert, die für HoloLens 2 verwendet werden. Sie werden beibehalten, um weiterhin auf den unterstützten Geräten zu funktionieren. In Zukunft wird es eine neue Reihe von Lernprogrammen geben, die die Entwicklung für HoloLens 2 demonstrieren. Dieser Hinweis wird mit einem Link zu diesen Tutorials aktualisiert, sobald sie veröffentlicht werden.
In diesem Kurs lernen Sie, wie Sie benutzerdefinierte visuelle Inhalte in einem bereitgestellten Bild mithilfe Azure Custom Vision Funktionen in einer Mixed Reality-Anwendung erkennen.
Mit diesem Dienst können Sie ein Machine Learning-Modell mithilfe von Objektbildern trainieren. Anschließend verwenden Sie das trainierte Modell, um ähnliche Objekte zu erkennen, wie es bei der Kameraerfassung von Microsoft HoloLens oder einer an Ihren PC angeschlossenen Kamera für immersive Headsets (VR) möglich ist.
Azure Custom Vision ist ein Microsoft Cognitive Service, mit dem Entwickler benutzerdefinierte Bildklassifizierer erstellen können. Diese Klassifizierungen können dann mit neuen Bildern verwendet werden, um Objekte innerhalb dieses neuen Bildes zu erkennen oder zu klassifizieren. Der Dienst bietet ein einfaches, leicht zu bedienendes Online-Portal zur Optimierung des Prozesses. Weitere Informationen finden Sie auf der Seite Azure Custom Vision Service.
Nach Abschluss dieses Kurses verfügen Sie über eine Mixed Reality-Anwendung, die in zwei Modi arbeiten kann:
Analysemodus: Manuelles Einrichten des Custom Vision-Diensts durch Hochladen von Bildern, Erstellen von Tags und Trainieren des Dienstes für die Erkennung verschiedener Objekte (in diesem Fall Maus und Tastatur). Anschließend erstellen Sie eine HoloLens-App, die Bilder mit der Kamera aufnimmt, und versuchen, diese Objekte in der realen Welt zu erkennen.
Trainingsmodus: Sie implementieren Code, der einen "Trainingsmodus" in Ihrer App aktiviert. Im Trainingsmodus können Sie Bilder mit der HoloLens-Kamera erfassen, die aufgenommenen Bilder in den Dienst hochladen und das Custom Vision-Modell trainieren.
In diesem Kurs erfahren Sie, wie Sie die Ergebnisse aus dem Custom Vision Service in eine Unity-basierte Beispielanwendung übertragen. Es liegt an Ihnen, diese Konzepte auf eine benutzerdefinierte Anwendung anzuwenden, die Sie möglicherweise erstellen.
Unterstützung für Geräte
| Kurs | HoloLens | Immersive Headsets |
|---|---|---|
| MR und Azure 302b: Custom Vision | ✔️ | ✔️ |
Hinweis
Während sich dieser Kurs hauptsächlich auf HoloLens konzentriert, können Sie das, was Sie in diesem Kurs gelernt haben, auch auf immersive Windows Mixed Reality (VR)-Headsets anwenden. Da immersive Headsets (VR-Headsets) keine barrierefreien Kameras haben, benötigen Sie eine externe Kamera, die an Ihren PC angeschlossen ist. Während Sie dem Kurs folgen, sehen Sie Hinweise zu allen Änderungen, die Sie möglicherweise vornehmen müssen, um immersive (VR) Headsets zu unterstützen.
Voraussetzungen
Hinweis
Dieses Tutorial richtet sich an Entwickler, die über grundlegende Erfahrungen mit Unity und C# verfügen. Bitte beachten Sie auch, dass die Voraussetzungen und schriftlichen Anweisungen in diesem Dokument das darstellen, was zum Zeitpunkt der Erstellung dieses Dokuments (Juli 2018) getestet und verifiziert wurde. Es steht Ihnen frei, die neueste Software zu verwenden, wie im Artikel Installieren der Tools aufgeführt, obwohl nicht davon ausgegangen werden sollte, dass die Informationen in diesem Kurs perfekt mit dem übereinstimmen, was Sie in neuerer Software als der unten aufgeführten finden.
Wir empfehlen folgende Hard- und Software für diesen Kurs:
- Ein Entwicklungs-PC, kompatibel mit Windows Mixed Reality für die immersive (VR) Headset-Entwicklung
- Windows 10 Fall Creators Update (oder höher) mit aktiviertem Entwicklermodus
- Neuestes Windows 10 SDK
- Unity 2017.4
- Visual Studio 2017
- Ein Windows Mixed Reality Immersive (VR) Headset oder Microsoft HoloLens mit aktiviertem Entwicklermodus
- Eine Kamera, die mit Ihrem PC verbunden ist (für die immersive Headset-Entwicklung)
- Internetzugriff für Azure-Setup und Custom Vision-API-Abruf
- Eine Serie von mindestens fünf (5) Bildern (zehn (10) empfohlen) für jedes Objekt, das der Custom Vision-Dienst erkennen soll. Wenn Sie möchten, können Sie die bereits mit diesem Kurs bereitgestellten Bilder (eine Computermaus und eine Tastatur) verwenden.
Vorbereitende Schritte
- Um Probleme beim Erstellen dieses Projekts zu vermeiden, wird dringend empfohlen, das in diesem Tutorial erwähnte Projekt in einem Stammordner oder in der Nähe des Stammordners zu erstellen (lange Ordnerpfade können zur Buildzeit zu Problemen führen).
- Einrichten und Testen Ihrer HoloLens. Wenn Sie Unterstützung beim Einrichten Ihrer HoloLens benötigen, lesen Sie unbedingt den Artikel zum Einrichten von HoloLens.
- Es empfiehlt sich, die Kalibrierung und Sensoroptimierung durchzuführen, wenn Sie mit der Entwicklung einer neuen HoloLens-App beginnen (manchmal kann es hilfreich sein, diese Aufgaben für jeden Benutzer auszuführen).
Hilfe zur Kalibrierung erhalten Sie unter diesem Link zum Artikel zur HoloLens-Kalibrierung.
Hilfe zur Sensoroptimierung finden Sie unter diesem Link zum Artikel zur HoloLens-Sensoroptimierung.
Kapitel 1: Das Custom Vision-Dienstportal
Um den Custom Vision Service in Azure verwenden zu können, müssen Sie eine Instance des Diensts konfigurieren, die Ihrer Anwendung zur Verfügung gestellt werden soll.
Navigieren Sie zunächst zur Hauptseite des Custom Vision Service.
Klicken Sie auf die Schaltfläche Erste Schritte .
Melden Sie sich beim Custom Vision-Dienstportal an.
Hinweis
Wenn Sie noch nicht über ein Azure-Konto verfügen, müssen Sie eins erstellen. Wenn Sie dieses Lernprogramm in einem Klassenzimmer oder Labor durchführen, bitten Sie Ihren Dozenten oder eine der Aufsichtspersonen um Hilfe beim Einrichten Ihres neuen Kontos.
Sobald Sie zum ersten Mal angemeldet sind, werden Sie mit dem Bereich "Nutzungsbedingungen" aufgefordert. Klicken Sie auf das Kontrollkästchen, um den Bedingungen zuzustimmen. Klicken Sie dann auf Ich stimme zu.
Nachdem Sie den Bedingungen zugestimmt haben, werden Sie zum Abschnitt "Projekte " des Portals navigiert. Klicken Sie auf Neues Projekt.
Auf der rechten Seite wird eine Registerkarte angezeigt, auf der Sie aufgefordert werden, einige Felder für das Projekt anzugeben.
Fügen Sie einen Namen für Ihr Projekt ein.
Fügen Sie eine Beschreibung für Ihr Projekt ein (optional).
Wählen Sie eine Ressourcengruppe aus, oder erstellen Sie eine neue. Eine Ressourcengruppe bietet eine Möglichkeit zum Überwachen, Steuern des Zugriffs, Bereitstellen und Verwalten der Abrechnung für eine Sammlung von Azure-Ressourcen. Es wird empfohlen, alle Azure Services, die einem einzelnen Projekt zugeordnet sind (z. B. diese Kurse), in einer gemeinsamen Ressourcengruppe zu halten.
Festlegen der Projekttypen auf "Klassifizierung"
Legen Sie die Domänen auf "Allgemein" fest.
Weitere Informationen zu Azure-Ressourcengruppen finden Sie im Artikel zu Ressourcengruppen.
Sobald Sie fertig sind, klicken Sie auf Projekt erstellen, Sie werden zur Projektseite des Custom Vision Service weitergeleitet.
Kapitel 2 – Trainieren Ihres Custom Vision-Projekts
Sobald Sie sich im Custom Vision-Portal befinden, besteht Ihr Hauptziel darin, Ihr Projekt darin zu trainieren, bestimmte Objekte in Bildern zu erkennen. Sie benötigen mindestens fünf (5) Bilder (obwohl zehn (10) bevorzugt werden, für jedes Objekt, das Ihre Anwendung erkennen soll. Sie können die in diesem Kurs bereitgestellten Bilder (eine Computermaus und eine Tastatur) verwenden.
So trainieren Sie Ihr Custom Vision Service-Projekt:
Klicken Sie auf die + Schaltfläche neben Tags.
Fügen Sie den Namen des Objekts hinzu, das Sie erkennen möchten. Klicken Sie auf Speichern.
Sie werden feststellen, dass Ihr Tag hinzugefügt wurde (möglicherweise müssen Sie Ihre Seite neu laden, damit es angezeigt wird). Klicken Sie auf das Kontrollkästchen neben Ihrem neuen Tag, falls es nicht bereits aktiviert ist.
Klicken Sie in der Mitte der Seite auf Bilder hinzufügen .
Klicken Sie auf Lokale Dateien durchsuchen, suchen Sie die Bilder, die Sie hochladen möchten, und wählen Sie sie dann aus. Das Minimum beträgt fünf (5). Denken Sie daran, dass alle diese Bilder das Objekt enthalten sollten, das Sie trainieren.
Hinweis
Sie können mehrere Bilder gleichzeitig zum Hochladen auswählen.
Sobald Sie die Bilder auf der Registerkarte sehen können, wählen Sie das entsprechende Tag im Feld "Meine Tags " aus.
Klicken Sie auf Dateien hochladen. Die Dateien werden hochgeladen. Nachdem Sie die Bestätigung des Uploads erhalten haben, klicken Sie auf Fertig.
Wiederholen Sie den gleichen Vorgang, um ein neues Tag mit dem Namen "Tastatur" zu erstellen und die entsprechenden Fotos dafür hochzuladen. Stellen Sie sicher, dass SieMaus deaktivieren, sobald Sie die neuen Tags erstellt haben, um das Fenster Bilder hinzufügen anzuzeigen.
Sobald Sie beide Tags eingerichtet haben, klicken Sie auf "Trainieren", und die erste Trainingsiteration beginnt mit dem Erstellen.
Sobald es erstellt wurde, werden Sie zwei Schaltflächen mit den Namen Als Standard festlegen und Vorhersage-URL sehen. Klicken Sie zuerst auf Als Standard festlegen und dann auf Vorhersage-URL.
Hinweis
Die Endpunkt-URL, die dadurch bereitgestellt wird, wird auf die Iteration festgelegt, die als Standard markiert wurde. Wenn du also später eine neue Iteration vornimmst und sie als Standard aktualisierst, musst du deinen Code nicht ändern.
Nachdem Sie auf Vorhersage-URL geklickt haben, öffnen Sie den Editor, kopieren Sie die URL und den Vorhersageschlüssel, und fügen Sie sie ein, damit Sie sie später im Code abrufen können, wenn Sie sie benötigen.
Klicken Sie auf das Zahnrad oben rechts auf dem Bildschirm.
Kopieren Sie den Trainingsschlüssel und fügen Sie ihn zur späteren Verwendung in einen Editor ein.
Kopieren Sie auch Ihre Projekt-ID, und fügen Sie sie zur späteren Verwendung in Ihre Editor-Datei ein.
Kapitel 3 - Einrichten des Unity-Projekts
Das Folgende ist ein typisches Setup für die Entwicklung mit Mixed Reality und stellt daher eine gute Vorlage für andere Projekte dar.
Öffnen Sie Unity , und klicken Sie auf Neu.
Sie müssen nun einen Unity-Projektnamen angeben. Fügen Sie AzureCustomVision ein. Stellen Sie sicher, dass die Projektvorlage auf 3D festgelegt ist. Legen Sie den Speicherort auf einen für Sie geeigneten Ort fest (denken Sie daran, dass es besser ist, näher an den Stammverzeichnissen zu sein). Klicken Sie dann auf Projekt erstellen.
Bei geöffnetem Unity lohnt es sich zu überprüfen, ob der Standardskript-Editor auf Visual Studio eingestellt ist. Wechseln Sie zu Einstellungenbearbeiten>, und navigieren Sie dann im neuen Fenster zu Externe Tools. Ändern Sie den externen Skript-Editor in Visual Studio 2017. Schließen Sie das Fenster "Einstellungen ".
Wechseln Sie anschließend zu "Dateibuildeinstellungen>", wählen Sie "Universelle Windows-Plattform" aus, und klicken Sie dann auf die Schaltfläche "Plattform wechseln", um Ihre Auswahl anzuwenden.
Während Sie sich noch in den Dateibuildeinstellungen > befinden, stellen Sie Folgendes sicher:
Das Zielgerät ist auf HoloLens eingestellt
Legen Sie für die immersiven Headsets "Zielgerät " auf "Beliebiges Gerät" fest.
Build Type is set to D3D
SDK ist auf die neueste installierte Version festgelegt
Visual Studio-Version ist auf die neueste installierte Version festgelegt
"Build and Run" ist auf "Lokaler Computer" festgelegt
Speichern Sie die Szene, und fügen Sie sie dem Build hinzu.
Wählen Sie dazu "Offene Szenen hinzufügen" aus. Ein Speicherfenster wird angezeigt.
Erstellen Sie einen neuen Ordner für diese und alle zukünftigen Szenen und wählen Sie dann die Schaltfläche "Neuer Ordner ", um einen neuen Ordner zu erstellen, nennen Sie ihn "Szenen".
Öffnen Sie den neu erstellten Szenenordner, geben Sie im Textfeld Dateiname:CustomVisionScene ein und klicken Sie dann auf Speichern.
Beachten Sie, dass Sie Ihre Unity-Szenen im Ordner "Assets " speichern müssen, da sie dem Unity-Projekt zugeordnet sein müssen. Das Erstellen des Szenenordners (und anderer ähnlicher Ordner) ist eine typische Art, ein Unity-Projekt zu strukturieren.
Die übrigen Einstellungen in den Buildeinstellungen sollten vorerst als Standard beibehalten werden.
Klicken Sie im Fenster " Buildeinstellungen " auf die Schaltfläche "Playereinstellungen ". Dadurch wird der entsprechende Bereich in dem Bereich geöffnet, in dem sich der Inspektor befindet.
In diesem Bereich müssen einige Einstellungen überprüft werden:
Auf der Registerkarte "Andere Einstellungen ":
Die Skriptlaufzeitversion sollte experimentell (.NET 4.6-Äquivalent) sein, was einen Neustart des Editors erforderlich macht.
Skripterstellung für das Back-End muss .NET sein.
API-Kompatibilitätsgrad muss .NET 4.6 sein.
Überprüfen Sie auf der Registerkarte Veröffentlichungseinstellungen unter Funktionen:
InternetClient
Webcam
Mikrofon
Weiter unten im Bereich, in XR-Einstellungen (unten unter Veröffentlichungseinstellungen), markieren Sie Virtual Reality unterstützt, stellen Sie sicher, dass das Windows Mixed Reality SDK hinzugefügt ist.
Zurück in den Build-Einstellungen ist Unity C# Projects nicht mehr ausgegraut; Aktivieren Sie das Kontrollkästchen daneben.
Schließen Sie das Fenster mit den Buildeinstellungen.
Speichern Sie Ihre Szene und Ihr Projekt (FILE > SAVE SCENE / FILE > SAVE PROJECT).
Kapitel 4 - Importieren der Newtonsoft-DLL in Unity
Wichtig
Wenn Sie die Unity Setup-Komponente dieses Kurses überspringen und direkt mit dem Code fortfahren möchten, können Sie dieses Paket "Azure-MR-302b.unitypackage" herunterladen, es als benutzerdefiniertes Paket in Ihr Projekt importieren und dann mit Kapitel 6 fortfahren.
Dieser Kurs erfordert die Verwendung der Newtonsoft-Bibliothek , die Sie als DLL zu Ihren Medienobjekten hinzufügen können. Das Paket, das diese Bibliothek enthält, kann von diesem Link heruntergeladen werden. Um die Newtonsoft-Bibliothek in Ihr Projekt zu importieren, verwenden Sie das Unity-Paket, das mit diesem Kurs geliefert wurde.
Fügen Sie die .unitypackage zu Unity hinzu, indem Sie die > Menüoption AssetsImportPackage>Custom Package CustomPackage verwenden.
Stellen Sie im angezeigten Feld Import Unity Package sicher, dass alles unter (einschließlich) Plugins ausgewählt ist.
Klicken Sie auf die Schaltfläche Importieren , um die Elemente zu Ihrem Projekt hinzuzufügen.
Gehen Sie in der Projektansicht unter Plugins in den Newtonsoft-Ordner und wählen Sie das Newtonsoft.Json-Plugin aus.
Wenn Sie das Newtonsoft.Json-Plugin ausgewählt haben, stellen Sie sicher, dass Any Platformdeaktiviert ist, stellen Sie dann sicher, dass WSAPlayer ebenfalls deaktiviert ist, und klicken Sie dann auf Übernehmen. Dies dient nur zur Bestätigung, dass die Dateien ordnungsgemäß konfiguriert sind.
Hinweis
Wenn Sie diese Plugins markieren, werden sie so konfiguriert, dass sie nur im Unity-Editor verwendet werden können. Es gibt einen anderen Satz von ihnen im WSA-Ordner, der verwendet wird, nachdem das Projekt aus Unity exportiert wurde.
Als nächstes müssen Sie den WSA-Ordner im Newtonsoft-Ordner öffnen. Es wird eine Kopie derselben Datei angezeigt, die Sie gerade konfiguriert haben. Wählen Sie die Datei aus, und stellen Sie dann im Inspektor sicher, dass
- "Any Platform is Unchecked
- nurWSAPlayer ist geprüft
- Don't process ist aktiviert
Kapitel 5 - Kameraeinstellung
Wählen Sie im Hierarchiebereich die Hauptkamera aus.
Sobald Sie diese Option ausgewählt haben, können Sie alle Komponenten der Hauptkamera im Inspektorfenster sehen.
Das Kameraobjekt muss den Namen "Hauptkamera " haben (beachten Sie die Schreibweise!)
Das Hauptkamera-Tag muss auf MainCamera eingestellt sein (beachten Sie die Schreibweise!)
Stellen Sie sicher, dass die Transformationsposition auf 0, 0, 0 festgelegt ist
Legen Sie "Kennzeichnungen löschen" auf "Volltonfarbe " fest (ignorieren Sie dies für immersives Headset).
Legen Sie die Hintergrundfarbe der Kamerakomponente auf Schwarz, Alpha 0 fest (Hex-Code: #00000000) (ignorieren Sie dies für ein immersives Headset).
Kapitel 6 - Erstellen der CustomVisionAnalyser-Klasse.
An diesem Punkt sind Sie bereit, Code zu schreiben.
Sie beginnen mit der Klasse CustomVisionAnalyser .
Hinweis
Die Aufrufe des Custom Vision-Diensts im unten gezeigten Code erfolgen mithilfe der Custom Vision-REST-API. Auf diese Weise erfahren Sie, wie Sie diese API implementieren und nutzen können (nützlich, um zu verstehen, wie Sie etwas Ähnliches selbst implementieren können). Beachten Sie, dass Microsoft ein Custom Vision Service-SDK anbietet, das auch zum Aufrufen des Diensts verwendet werden kann. Weitere Informationen finden Sie im Artikel zum Custom Vision Service SDK.
Diese Klasse ist verantwortlich für:
Laden des neuesten als Byte-Array erfassten Bildes.
Senden des Bytearrays zur Analyse an Ihre Azure Custom Vision Service-instance.
Erhalten der Antwort als JSON-Zeichenfolge.
Deserialisieren der Antwort und Übergeben der resultierenden Vorhersage an die SceneOrganiser-Klasse , die dafür sorgt, wie die Antwort angezeigt werden soll.
So erstellen Sie diese Klasse:
Klicken Sie mit der rechten Maustaste in den Asset-Ordner im Projektfenster und klicken Sie dann auf "Ordner erstellen>". Rufen Sie den Ordner Skripts auf.
Doppelklicken Sie auf den soeben erstellten Ordner, um ihn zu öffnen.
Klicken Sie mit der rechten Maustaste in den Ordner, und klicken Sie dann aufC#-Skripterstellen>. Nennen Sie das Skript CustomVisionAnalyser.
Doppelklicken Sie auf das neue CustomVisionAnalyser-Skript , um es mit Visual Studio zu öffnen.
Aktualisiere die Namespaces oben in deiner Datei so, dass sie folgendem entsprechen:
using System.Collections; using System.IO; using UnityEngine; using UnityEngine.Networking; using Newtonsoft.Json;Fügen Sie in der CustomVisionAnalyser-Klasse die folgenden Variablen hinzu:
/// <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;Hinweis
Stellen Sie sicher, dass Sie Ihren Vorhersageschlüssel in die Vorhersageschlüsselvariable und Ihren Vorhersageendpunkt in die Vorhersageendpunktvariable einfügen . Sie haben diese weiter oben im Kurs in den Editor kopiert.
Code für Awake() muss jetzt hinzugefügt werden, um die Instanzvariable zu initialisieren:
/// <summary> /// Initialises this class /// </summary> private void Awake() { // Allows this instance to behave like a singleton Instance = this; }Löschen Sie die Methoden Start() und Update().
Fügen Sie als Nächstes die Coroutine hinzu (mit der statischen Methode GetImageAsByteArray() darunter), die die Ergebnisse der Analyse des von der ImageCapture-Klasse erfassten Bildes erhält.
Hinweis
In der AnalyseImageCapture-Coroutine gibt es einen Aufruf der SceneOrganiser-Klasse , den Sie noch erstellen müssen. Lassen Sie diese Zeilen daher vorerst kommentiert.
/// <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); }Stellen Sie sicher, dass Sie Ihre Änderungen in Visual Studio speichern, bevor Sie zu Unity zurückkehren.
Kapitel 7 - Erstellen der CustomVisionObjects-Klasse
Die Klasse, die Sie jetzt erstellen, ist die CustomVisionObjects-Klasse .
Dieses Skript enthält eine Reihe von Objekten, die von anderen Klassen verwendet werden, um die Aufrufe des Custom Vision Service zu serialisieren und zu deserialisieren.
Warnung
Es ist wichtig, dass Sie den Endpunkt notieren, den Ihnen der Custom Vision-Dienst bereitstellt, da die folgende JSON-Struktur für die Arbeit mit Custom Vision v2.0 eingerichtet wurde. Wenn Sie eine andere Version verwenden, müssen Sie möglicherweise die folgende Struktur aktualisieren.
So erstellen Sie diese Klasse:
Klicken Sie mit der rechten Maustaste in den Ordner "Skripte", und klicken Sie dann auf "C#-Skripterstellen>". Rufen Sie das Skript CustomVisionObjects auf.
Doppelklicken Sie auf das neue CustomVisionObjects-Skript , um es mit Visual Studio zu öffnen.
Füge die folgenden Namespaces am Anfang der Datei hinzu:
using System; using System.Collections.Generic; using UnityEngine; using UnityEngine.Networking;Löschen Sie die Methoden Start() und Update() innerhalb der Klasse CustomVisionObjects . Diese Klasse sollte nun leer sein.
Fügen Sie die folgenden Klassen außerhalb der CustomVisionObjects-Klasse hinzu. Diese Objekte werden von der Newtonsoft-Bibliothek verwendet, um die Antwortdaten zu serialisieren und zu deserialisieren:
// 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; } }
Kapitel 8: Erstellen der VoiceRecognizer-Klasse
Diese Klasse erkennt die Spracheingabe des Benutzers.
So erstellen Sie diese Klasse:
Klicken Sie mit der rechten Maustaste in den Ordner "Skripte", und klicken Sie dann auf "C#-Skripterstellen>". Rufen Sie das Skript VoiceRecognizer auf.
Doppelklicken Sie auf das neue VoiceRecognizer-Skript , um es mit Visual Studio zu öffnen.
Fügen Sie die folgenden Namespaces über der VoiceRecognizer-Klasse hinzu:
using System; using System.Collections.Generic; using System.Linq; using UnityEngine; using UnityEngine.Windows.Speech;Fügen Sie dann die folgenden Variablen innerhalb der VoiceRecognizer-Klasse oberhalb der Start()- Methode hinzu:
/// <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>();Fügen Sie die Methoden Awake() und Start() hinzu, wobei letztere die Benutzerschlüsselwörter einrichtet, die beim Zuordnen eines Tags zu einem Bild erkannt werden:
/// <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; }Löschen Sie die Update ()- Methode.
Fügen Sie den folgenden Handler hinzu, der aufgerufen wird, wenn eine Spracheingabe erkannt wird:
/// <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(); } }Stellen Sie sicher, dass Sie Ihre Änderungen in Visual Studio speichern, bevor Sie zu Unity zurückkehren.
Hinweis
Machen Sie sich keine Sorgen über Code, der einen Fehler zu haben scheint, da Sie bald weitere Klassen bereitstellen werden, die diese Probleme beheben.
Kapitel 9 - Erstellen der CustomVisionTrainer-Klasse
Diese Klasse verkettet eine Reihe von Webaufrufen, um den Custom Vision Service zu trainieren. Jeder Aufruf wird direkt über dem Code ausführlich erklärt.
So erstellen Sie diese Klasse:
Klicken Sie mit der rechten Maustaste in den Ordner "Skripte", und klicken Sie dann auf "C#-Skripterstellen>". Rufen Sie das Skript CustomVisionTrainer auf.
Doppelklicken Sie auf das neue CustomVisionTrainer-Skript , um es mit Visual Studio zu öffnen.
Fügen Sie die folgenden Namespaces über der CustomVisionTrainer-Klasse hinzu:
using Newtonsoft.Json; using System.Collections; using System.Collections.Generic; using System.IO; using System.Text; using UnityEngine; using UnityEngine.Networking;Fügen Sie dann die folgenden Variablen innerhalb der CustomVisionTrainer-Klasse oberhalb der Start ()- Methode hinzu.
Hinweis
Die hier verwendete Schulungs-URL wird in der Dokumentation zu Custom Vision-Schulungen 1.2 bereitgestellt und weist eine Struktur wie folgt auf:https://southcentralus.api.cognitive.microsoft.com/customvision/v1.2/Training/projects/{projectId}/
Weitere Informationen finden Sie in der Referenz-API zu Custom Vision-Schulung v1.2.Warnung
Es ist wichtig, dass Sie den Endpunkt notieren, den der Custom Vision-Dienst für den Trainingsmodus bereitstellt, da die verwendete JSON-Struktur (innerhalb der CustomVisionObjects-Klasse) für die Arbeit mit Custom Vision Training v1.2 eingerichtet wurde. Wenn Sie eine andere Version haben, müssen Sie möglicherweise die Objektstruktur aktualisieren.
/// <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;Wichtig
Stellen Sie sicher, dass Sie Ihren Dienstschlüsselwert (Trainingsschlüssel) und den Wert der Projekt-ID hinzufügen, die Sie zuvor notiert haben. Dies sind die Werte, die Sie zuvor im Kurs (Kapitel 2, Schritt 10 und höher) im Portal gesammelt haben.
Fügen Sie die folgenden Start()- und Awake()- Methoden hinzu. Diese Methoden werden bei der Initialisierung aufgerufen und enthalten den Aufruf zum Einrichten der Benutzeroberfläche:
/// <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); }Löschen Sie die Update ()- Methode. Diese Klasse wird es nicht benötigen.
Fügen Sie die Methode RequestTagSelection() hinzu. Diese Methode wird zuerst aufgerufen, wenn ein Image auf dem Gerät erfasst und gespeichert wurde und nun an den Custom Vision Service zum Trainieren übermittelt werden kann. Diese Methode zeigt in der Trainingsoberfläche eine Reihe von Schlüsselwörtern an, die der Benutzer verwenden kann, um das aufgenommene Bild zu markieren. Außerdem wird die VoiceRecognizer-Klasse benachrichtigt, damit sie den Benutzer auf Spracheingaben anhört.
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(); }Fügen Sie die VerifyTag()- Methode hinzu. Diese Methode empfängt die von der VoiceRecognizer-Klasse erkannte Spracheingabe, überprüft deren Gültigkeit und beginnt dann mit dem Trainingsprozess.
/// <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)); } }Fügen Sie die SubmitImageForTraining()- Methode hinzu. Mit dieser Methode wird der Custom Vision Service-Schulungsprozess gestartet. Der erste Schritt besteht darin, die Tag-ID vom Dienst abzurufen, die mit der überprüften Spracheingabe des Benutzers verknüpft ist. Die Tag-ID wird dann zusammen mit dem Bild hochgeladen.
/// <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()); }Fügen Sie die Methode TrainCustomVisionProject() hinzu. Sobald das Bild übermittelt und markiert wurde, wird diese Methode aufgerufen. Es wird eine neue Iteration erstellt, die mit allen zuvor an den Dienst übermittelten Bildern sowie dem soeben hochgeladenen Bild trainiert wird. Nach Abschluss des Trainings ruft diese Methode eine Methode auf, um die neu erstellte Iteration als Standard festzulegen, sodass der Endpunkt, den Sie für die Analyse verwenden, die neueste trainierte Iteration ist.
/// <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)); } } }Fügen Sie die SetDefaultIteration()- Methode hinzu. Mit dieser Methode wird die zuvor erstellte und trainierte Iteration als Standard festgelegt. Nach Abschluss des Vorgangs muss diese Methode die vorherige Iteration löschen, die im Dienst vorhanden ist. Zum Zeitpunkt der Abfassung dieses Kurses gibt es ein Limit von maximal zehn (10) Iterationen, die gleichzeitig im Dienst existieren dürfen.
/// <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)); } } }Fügen Sie die DeletePreviousIteration()- Methode hinzu. Diese Methode sucht und löscht die vorherige, nicht standardmäßige Iteration:
/// <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(); } }Die letzte Methode, die in dieser Klasse hinzugefügt werden muss, ist die GetImageAsByteArray()- Methode, die in den Webaufrufen verwendet wird, um das erfasste Bild in ein Byte-Array zu konvertieren.
/// <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); }Stellen Sie sicher, dass Sie Ihre Änderungen in Visual Studio speichern, bevor Sie zu Unity zurückkehren.
Kapitel 10 – Erstellen der SceneOrganiser-Klasse
Diese Klasse wird:
Erstellen Sie ein Cursorobjekt , das an die Hauptkamera angehängt werden soll.
Erstellen Sie ein Label-Objekt , das angezeigt wird, wenn der Dienst die realen Objekte erkennt.
Richten Sie die Hauptkamera ein, indem Sie die entsprechenden Komponenten daran anbringen.
Im Analysemodus werden die Labels zur Laufzeit im entsprechenden Weltbereich relativ zur Position der Hauptkamera gespawnt, und die vom Custom Vision-Dienst empfangenen Daten angezeigt.
Im Trainingsmodus wird die Benutzeroberfläche gespawnt, auf der die verschiedenen Phasen des Trainingsprozesses angezeigt werden.
So erstellen Sie diese Klasse:
Klicken Sie mit der rechten Maustaste in den Ordner "Skripte", und klicken Sie dann auf "C#-Skripterstellen>". Nennen Sie das Skript SceneOrganiser.
Doppelklicken Sie auf das neue SceneOrganiser-Skript , um es mit Visual Studio zu öffnen.
Sie benötigen nur einen Namespace, entfernen Sie die anderen oberhalb der SceneOrganiser-Klasse :
using UnityEngine;Fügen Sie dann die folgenden Variablen innerhalb der SceneOrganiser-Klasse oberhalb der Start ()- Methode hinzu:
/// <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;Löschen Sie die Methoden Start() und Update().
Fügen Sie direkt unter den Variablen die Awake()- Methode hinzu, die die Klasse initialisiert und die Szene einrichtet.
/// <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"); }Fügen Sie nun die Methode CreateCameraCursor() hinzu, die den Cursor der Hauptkamera erstellt und positioniert, und die Methode CreateLabel(), die das Analyse-Label-Objekt erstellt.
/// <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; }Fügen Sie die SetCameraStatus()-Methode hinzu, die Nachrichten verarbeitet, die für das Textnetz bestimmt sind und den Status der Kamera bereitstellen.
/// <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>"; } }Fügen Sie die Methoden PlaceAnalysisLabel() und SetTagsToLastLabel() hinzu, die die Daten aus dem Custom Vision-Dienst erzeugen und in der Szene anzeigen.
/// <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")}"); } } } }Fügen Sie schließlich die CreateTrainingUI()- Methode hinzu, die die Benutzeroberfläche erzeugt, die die mehreren Phasen des Trainingsprozesses anzeigt, wenn sich die Anwendung im Trainingsmodus befindet. Diese Methode wird auch verwendet, um das Kamera-Status-Objekt zu erstellen.
/// <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; }Stellen Sie sicher, dass Sie Ihre Änderungen in Visual Studio speichern, bevor Sie zu Unity zurückkehren.
Wichtig
Bevor Sie fortfahren, öffnen Sie die CustomVisionAnalyser-Klasse und entkommentieren Sie in der AnalyseLastImageCaptured()-Methode die folgenden Zeilen:
AnalysisObject analysisObject = new AnalysisObject();
analysisObject = JsonConvert.DeserializeObject<AnalysisObject>(jsonResponse);
SceneOrganiser.Instance.SetTagsToLastLabel(analysisObject);
Kapitel 11 - Erstellen der ImageCapture-Klasse
Die nächste Klasse, die Sie erstellen werden, ist die ImageCapture-Klasse .
Diese Klasse ist verantwortlich für:
Erfassen eines Bilds mit der HoloLens-Kamera und Speichern im App-Ordner .
Umgang mit Tippgesten des Benutzers.
Beibehalten des Enumerationswerts , der bestimmt, ob die Anwendung im Analyse - oder Trainingsmodus ausgeführt wird.
So erstellen Sie diese Klasse:
Wechseln Sie zum Ordner Skripts, den Sie zuvor erstellt haben.
Klicken Sie mit der rechten Maustaste in den Ordner, und klicken Sie dann auf C#-Skript erstellen>. Nennen Sie das Skript ImageCapture.
Doppelklicken Sie auf das neue ImageCapture-Skript , um es mit Visual Studio zu öffnen.
Ersetze die Namespaces oben in der Datei durch Folgendes:
using System; using System.IO; using System.Linq; using UnityEngine; using UnityEngine.XR.WSA.Input; using UnityEngine.XR.WSA.WebCam;Fügen Sie dann die folgenden Variablen innerhalb der ImageCapture-Klasse über der Start ()- Methode hinzu:
/// <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;Code für die Methoden Awake() und Start() muss jetzt hinzugefügt werden:
/// <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"); }Implementieren Sie einen Handler, der aufgerufen wird, wenn eine Tippgeste auftritt.
/// <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; } }Hinweis
Im Analysemodus fungiert die TapHandler-Methode als Schalter zum Starten oder Stoppen der Fotoaufnahmeschleife.
Im Trainingsmodus wird ein Bild von der Kamera aufgenommen.
Wenn der Cursor grün ist, bedeutet dies, dass die Kamera für die Aufnahme des Bildes verfügbar ist.
Wenn der Cursor rot ist, bedeutet dies, dass die Kamera beschäftigt ist.
Fügen Sie die Methode hinzu, die die Anwendung zum Starten des Abbilderfassungsprozesses und zum Speichern des Abbilds verwendet.
/// <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); }); }); }Fügen Sie die Handler hinzu, die aufgerufen werden, wenn das Foto aufgenommen wurde und wenn es für die Analyse bereit ist. Das Ergebnis wird dann an den CustomVisionAnalyser oder den CustomVisionTrainer übergeben, je nachdem, auf welchen Modus der Code eingestellt ist.
/// <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(); }Stellen Sie sicher, dass Sie Ihre Änderungen in Visual Studio speichern, bevor Sie zu Unity zurückkehren.
Nachdem alle Skripts abgeschlossen sind, kehren Sie zum Unity-Editor zurück, klicken Sie auf die SceneOrganizer-Klasse und ziehen Sie sie aus demOrdner Skripts in das Hauptkamera-Objekt im Hierarchiebereich.
Kapitel 12 - Vor dem Bau
Um einen gründlichen Test Ihrer Anwendung durchzuführen, müssen Sie sie auf Ihre HoloLens querladen.
Stellen Sie zuvor Folgendes sicher:
Alle in Kapitel 2 erwähnten Einstellungen sind korrekt eingestellt.
Alle Felder in der Hauptkamera, Inspektor-Bereich, sind ordnungsgemäß zugewiesen.
Das Skript SceneOrganiser ist an das Hauptkamera-Objekt angehängt.
Stellen Sie sicher, dass Sie Ihren Vorhersageschlüssel in die Vorhersageschlüssel-Variable einfügen.
Sie haben Ihren Vorhersageendpunkt in die Vorhersageendpunktvariable eingefügt .
Sie haben Ihren Trainingsschlüssel in die Variable trainingKey der Klasse CustomVisionTrainer eingefügt.
Sie haben Ihre Projekt-ID in die Variable projectId der Klasse CustomVisionTrainer eingefügt.
Kapitel 13 – Erstellen und Querladen Ihrer Anwendung
So starten Sie den Buildprozess :
Wechseln Sie zu den Einstellungen > für Dateibuild.
Tick Unity C#-Projekte.
Klicken Sie auf "Erstellen". Unity öffnet ein Fenster im Explorer, in dem Sie einen Ordner erstellen und dann auswählen müssen, in dem die App erstellt werden soll. Erstellen Sie diesen Ordner jetzt, und nennen Sie ihn App. Wenn Sie dann den App-Ordner ausgewählt haben, klicken Sie auf Ordner auswählen.
Unity beginnt mit dem Erstellen Ihres Projekts im App-Ordner .
Sobald Unity mit dem Erstellen fertig ist (es kann einige Zeit dauern), wird ein Explorer Fenster an der Stelle Ihres Builds geöffnet (überprüfen Sie Ihre Taskleiste, da sie möglicherweise nicht immer über Ihren Fenstern angezeigt wird, Sie aber über das Hinzufügen eines neuen Fensters informiert).
So stellen Sie es auf HoloLens bereit:
Sie benötigen die IP-Adresse Ihrer HoloLens (für Remote Deploy) und müssen sicherstellen, dass sich Ihre HoloLens im Entwicklermodus befindet. Gehen Sie dazu wie folgt vor:
Öffnen Sie beim Tragen Ihrer HoloLens die Einstellungen.
Wechseln Sie zu Netzwerk & InternetWi-Fi>>Erweiterte Optionen
Notieren Sie sich die IPv4-Adresse .
Navigieren Sie als Nächstes zurück zu "Einstellungen" und dann zu "& Sicherheit>für Entwickler aktualisieren"
Entwicklermodus aktivieren.
Navigieren Sie zu Ihrem neuen Unity-Build (dem App-Ordner ), und öffnen Sie die Projektmappendatei mit Visual Studio.
Wählen Sie in der Projektmappenkonfigurationdie Option Debuggen aus.
Wählen Sie in der Lösungsplattformx86, Remotecomputer aus. Sie werden aufgefordert, die IP-Adresse eines Remotegeräts (in diesem Fall HoloLens, das Sie notiert haben) einzugeben.
Wechseln Sie zum Menü "Erstellen ", und klicken Sie auf "Lösung bereitstellen ", um die Anwendung auf Ihre HoloLens querzuladen.
Ihre App sollte nun in der Liste der installierten Apps auf Ihrer HoloLens angezeigt werden und sofort gestartet werden können!
Hinweis
Für die Bereitstellung zu einem immersiven Headset legen Sie die Lösungsplattform auf "Lokaler Computer" und die Konfiguration auf "Debuggen" mit x86 als Plattform fest. Stellen Sie dann die Bereitstellung auf dem lokalen Computer bereit, indem Sie das Menüelement "Erstellen" verwenden und die Option "Lösung bereitstellen" auswählen.
So verwenden Sie die Anwendung
Um die App-Funktionalität zwischen Trainingsmodus und Vorhersagemodus zu wechseln, müssen Sie die AppMode-Variable aktualisieren, die sich in der Awake()- Methode befindet, die sich innerhalb der ImageCapture-Klasse befindet.
// Change this flag to switch between Analysis mode and Training mode
AppMode = AppModes.Training;
oder
// Change this flag to switch between Analysis mode and Training mode
AppMode = AppModes.Analysis;
Im Trainingsmodus :
Sehen Sie auf Maus oder Tastatur , und verwenden Sie die Tippgeste.
Als Nächstes wird Text angezeigt, in dem Sie aufgefordert werden, ein Tag einzugeben.
Sagen Sie entweder Maus oder Tastatur.
Im Vorhersagemodus :
Betrachten Sie ein Objekt, und verwenden Sie die Tippgeste.
Text wird angezeigt, wenn das Objekt mit der höchsten Wahrscheinlichkeit erkannt wird (dies ist normalisiert).
Kapitel 14 – Auswerten und Verbessern Ihres Custom Vision-Modells
Um Ihren Dienst genauer zu machen, müssen Sie das für die Vorhersage verwendete Modell weiter trainieren. Dies wird erreicht, indem Sie Ihre neue Anwendung verwenden, sowohl mit dem Trainings - als auch mit dem Vorhersagemodus , wobei letzterer einen Besuch des Portals erfordert, was in diesem Kapitel behandelt wird. Seien Sie darauf vorbereitet, Ihr Portal viele Male zu besuchen, um Ihr Modell kontinuierlich zu verbessern.
Wechseln Sie erneut zu Ihrem Azure Custom Vision Portal, und sobald Sie in Ihrem Projekt sind, wählen Sie die Registerkarte "Vorhersagen" (oben in der Mitte der Seite):
Sie sehen alle Bilder, die an Ihren Dienst gesendet wurden, während Ihre Anwendung ausgeführt wurde. Wenn Sie auf die Bilder zeigen, werden die für dieses Bild getroffenen Vorhersagen angezeigt:
Wählen Sie eines Ihrer Bilder aus, um es zu öffnen. Nach dem Öffnen sehen Sie die Vorhersagen für dieses Bild auf der rechten Seite. Wenn die Vorhersagen richtig waren und Sie dieses Bild zum Trainingsmodell Ihres Diensts hinzufügen möchten, klicken Sie auf das Eingabefeld Meine Tags , und wählen Sie das Tag aus, das Sie zuordnen möchten. Wenn Sie fertig sind, klicken Sie unten rechts auf die Schaltfläche Speichern und schließen , und fahren Sie mit dem nächsten Bild fort.
Sobald Sie zum Raster der Bilder zurückgekehrt sind, werden Sie feststellen, dass die Bilder, denen Sie Tags hinzugefügt (und gespeichert) haben, entfernt werden. Wenn Sie Bilder finden, von denen Sie glauben, dass sie Ihr markiertes Element nicht enthalten, können Sie sie löschen, indem Sie auf das Häkchen auf diesem Bild klicken (kann dies für mehrere Bilder tun) und dann in der oberen rechten Ecke der Rasterseite auf Löschen klicken. Im folgenden Popup können Sie entweder auf Ja, Löschen oder Nein klicken, um den Löschvorgang zu bestätigen bzw. abzubrechen.
Wenn Sie fortfahren möchten, klicken Sie oben rechts auf die grüne Schaltfläche "Trainieren ". Ihr Servicemodell wird mit allen Images trainiert, die Sie jetzt bereitgestellt haben (was es genauer macht). Stellen Sie nach Abschluss des Trainings sicher, dass Sie erneut auf die Schaltfläche Als Standard festlegen klicken, damit Ihre Vorhersage-URL weiterhin die aktuellste Iteration Ihres Diensts verwendet.
Ihre fertige Custom Vision-API-Anwendung
Herzlichen Glückwunsch, Sie haben eine Mixed Reality-App erstellt, die die Azure Custom Vision-API nutzt, um reale Objekte zu erkennen, das Dienstmodell zu trainieren und Vertrauen in das Gesehene zu zeigen.
Bonusübungen
Übung 1
Trainieren Sie Ihren Custom Vision Service, um weitere Objekte zu erkennen.
Übung 2
Um das Gelernte zu erweitern, führen Sie die folgenden Übungen aus:
Geben Sie einen Sound wieder, wenn ein Objekt erkannt wird.
Übung 3
Verwenden Sie die API, um Ihren Dienst mit den gleichen Bildern neu zu trainieren, die Ihre App analysiert, um den Dienst genauer zu machen (führen Sie sowohl Vorhersage als auch Training gleichzeitig durch).