HoloLens (1. Generation) und Azure 304: Gesichtserkennung
Hinweis
Die Tutorials der Mixed Reality Academy wurden im Hinblick auf HoloLens (1. Gen.) und immersive Mixed Reality-Headsets entworfen. Daher halten wir es für wichtig, diese Tutorials für Entwickler verfügbar zu halten, die noch nach Anleitung beim Entwickeln 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 gewartet, um weiterhin auf den unterstützten Geräten zu funktionieren. Es wird eine neue Reihe von Lernprogrammen geben, die in Zukunft veröffentlicht werden, die zeigen, wie sie für HoloLens 2 entwickelt werden. Dieser Hinweis wird mit einem Link zu diesen Lernprogrammen aktualisiert, wenn sie veröffentlicht werden.
In diesem Kurs erfahren Sie, wie Sie einer Mixed Reality-Anwendung mithilfe von Azure Cognitive Services mit der Microsoft Face-API Gesichtserkennungsfunktionen hinzufügen.
Azure Face API ist ein Microsoft-Dienst , der Entwicklern die fortschrittlichsten Gesichtsalgorithmen in der Cloud bietet. Die Gesichts-API verfügt über zwei Hauptfunktionen: Gesichtserkennung mit Attributen und Gesichtserkennung. Auf diese Weise können Entwickler einfach eine Gruppe von Gruppen für Gesichter festlegen und dann Abfragebilder später an den Dienst senden, um zu bestimmen, wem ein Gesicht gehört. Weitere Informationen finden Sie auf der Azure-Gesichtserkennungsseite.
Nachdem Sie diesen Kurs abgeschlossen haben, haben Sie eine Mixed Reality HoloLens-Anwendung, die folgende Aktionen ausführen kann:
- Verwenden Sie eine Tippgeste , um die Aufnahme eines Bilds mithilfe der HoloLens-Kamera an Bord zu initiieren.
- Senden Sie das erfasste Bild an den Azure Face API-Dienst .
- Erhalten Sie die Ergebnisse des Gesichts-API-Algorithmus .
- Verwenden Sie eine einfache Benutzeroberfläche, um den Namen der übereinstimmenden Personen anzuzeigen.
Dadurch erfahren Sie, wie Sie die Ergebnisse aus dem Face-API-Dienst in Ihre Unity-basierte Mixed Reality-Anwendung abrufen.
In Ihrer Anwendung liegt es an Ihnen, wie Sie die Ergebnisse in Ihr Design integrieren. Dieser Kurs wurde entwickelt, um Ihnen zu vermitteln, wie Sie einen Azure-Dienst in Ihr Unity-Projekt integrieren. Es ist Ihre Aufgabe, das Wissen zu nutzen, das Sie aus diesem Kurs gewinnen, um Ihre Mixed Reality-Anwendung zu verbessern.
Unterstützung für Geräte
| Kurs | HoloLens | Immersive Headsets |
|---|---|---|
| MR und Azure 304: Gesichtserkennung | ✔️ | ✔️ |
Hinweis
Während sich dieser Kurs hauptsächlich auf HoloLens konzentriert, können Sie auch das, was Sie in diesem Kurs lernen, auf Windows Mixed Reality immersive Headsets (VR) anwenden. Da immersive Headsets (VR) keine barrierefreien Kameras haben, benötigen Sie eine externe Kamera, die mit Ihrem PC verbunden ist. Während Sie den Kurs befolgen, werden Notizen zu allen Änderungen angezeigt, die Sie möglicherweise verwenden müssen, um immersive Headsets (VR) zu unterstützen.
Voraussetzungen
Hinweis
Dieses Lernprogramm wurde für Entwickler entwickelt, die grundlegende Erfahrung mit Unity und C# haben. Bitte beachten Sie auch, dass die Voraussetzungen und schriftlichen Anweisungen in diesem Dokument das zum Zeitpunkt der Schriftlichkeit (Mai 2018) getestet und überprüft wurden. Sie sind kostenlos, die neueste Software zu verwenden, wie im Artikel "Tools installieren" aufgeführt, aber es sollte nicht angenommen werden, dass die Informationen in diesem Kurs perfekt mit dem übereinstimmen, was Sie in neuerer Software finden als die unten aufgeführten.
Wir empfehlen die folgende Hardware und Software für diesen Kurs:
- Ein Entwicklungs-PC, kompatibel mit Windows Mixed Reality für die Entwicklung von immersiven (VR)-Headsets
- Windows 10 Fall Creators Update (oder höher) mit aktivierter Entwicklermodus
- Das neueste Windows 10 SDK
- Unity 2017.4
- Visual Studio 2017
- Ein immersives Windows Mixed Reality-Headset (VR) oder Microsoft HoloLens mit aktiviertem Entwicklermodus
- Eine Kamera, die an Ihren PC angeschlossen ist (für die entwicklung immersive Headsets)
- Internetzugriff für Azure-Setup und Gesichts-API-Abruf
Vor der Installation
- Um Probleme beim Erstellen dieses Projekts zu vermeiden, wird dringend empfohlen, das in diesem Lernprogramm erwähnte Projekt in einem Stamm- oder Near-Root-Ordner zu erstellen (lange Ordnerpfade können zu Buildzeit zu Problemen führen).
- Richten Sie Ihre HoloLens ein, und testen Sie sie. Wenn Sie Unterstützung beim Einrichten Ihrer HoloLens benötigen, besuchen Sie den HoloLens-Setupartikel.
- Es empfiehlt sich, beim Entwickeln einer neuen HoloLens-App Kalibrierung und Sensoroptimierung durchzuführen (manchmal kann es hilfreich sein, diese Aufgaben für jeden Benutzer auszuführen).
Hilfe zur Kalibrierung finden Sie unter diesem Link zum HoloLens-Kalibrierungsartikel.
Hilfe zur Sensoroptimierung finden Sie in diesem Link zum Artikel "HoloLens Sensor Tuning".
Kapitel 1 – Das Azure-Portal
Um den Face-API-Dienst in Azure zu verwenden, müssen Sie eine Instanz des Diensts konfigurieren, die Ihrer Anwendung zur Verfügung gestellt werden soll.
Melden Sie sich zuerst beim Azure-Portal an.
Hinweis
Wenn Sie noch nicht über ein Azure-Konto verfügen, müssen Sie ein Konto erstellen. Wenn Sie diesem Lernprogramm in einer Unterrichts- oder Laborsituation folgen, bitten Sie Ihren Kursleiter oder einen der Betreuer, Hilfe beim Einrichten Ihres neuen Kontos zu erhalten.
Nachdem Sie angemeldet sind, klicken Sie in der oberen linken Ecke auf "Neu ", und suchen Sie nach der Gesichts-API, drücken Sie die EINGABETASTE.
Hinweis
Das Wort "Neu" wurde möglicherweise durch "Ressource erstellen" in neueren Portalen ersetzt.
Die neue Seite enthält eine Beschreibung des Face-API-Diensts . Wählen Sie unten links in dieser Eingabeaufforderung die Schaltfläche "Erstellen " aus, um eine Zuordnung zu diesem Dienst zu erstellen.
Nachdem Sie auf "Erstellen" geklickt haben:
Fügen Sie ihren gewünschten Namen für diese Dienstinstanz ein.
Wählen Sie ein Abonnement aus.
Wählen Sie das für Sie geeignete Preisniveau aus, wenn Sie zum ersten Mal einen Face-API-Dienst erstellen, sollte ihnen eine kostenlose Stufe (mit dem Namen F0) zur Verfügung stehen.
Wählen Sie eine Ressourcengruppe aus, oder erstellen Sie eine neue. Eine Ressourcengruppe bietet eine Möglichkeit, die Abrechnung für eine Sammlung von Azure-Ressourcen zu überwachen, zu steuern, den Zugriff zu steuern, bereitzustellen und zu verwalten. Es wird empfohlen, alle Azure-Dienste, die einem einzelnen Projekt (z. B. diesen Laboren) zugeordnet sind, unter einer gemeinsamen Ressourcengruppe zu halten.
Wenn Sie mehr über Azure-Ressourcengruppen erfahren möchten, besuchen Sie bitte den Artikel zur Ressourcengruppe.
Die UWP-App Person Maker, die Sie später verwenden, erfordert die Verwendung von "West US" für den Standort.
Sie müssen auch bestätigen, dass Sie die auf diesen Dienst angewendeten Allgemeinen Geschäftsbedingungen verstanden haben.
Wählen Sie Erstellen* aus.
Nachdem Sie auf "Erstellen" geklickt haben, müssen Sie warten, bis der Dienst erstellt wurde. Dies kann eine Minute dauern.
Sobald die Dienstinstanz erstellt wurde, wird im Portal eine Benachrichtigung angezeigt.
Klicken Sie auf die Benachrichtigungen, um Ihre neue Dienstinstanz zu erkunden.
Wenn Sie fertig sind, klicken Sie in der Benachrichtigung auf die Schaltfläche "Zur Ressource wechseln", um Ihre neue Dienstinstanz zu erkunden.
In diesem Lernprogramm muss Ihre Anwendung Aufrufe an Ihren Dienst tätigen, was über den Abonnementschlüssel Ihres Diensts erfolgt. Auf der Schnellstartseite ihres Face-API-Diensts ist der erste Punkt 1, um Ihre Schlüssel zu erfassen.
Wählen Sie auf der Seite "Dienst " entweder den blauen Link "Schlüssel " (wenn sie sich auf der Schnellstartseite befinden) oder den Link "Schlüssel " im Navigationsmenü "Dienste" (links, mit dem Symbol "Schlüssel" gekennzeichnet) aus, um Ihre Tasten anzuzeigen.
Hinweis
Notieren Sie sich eines der Schlüssel, und schützen Sie ihn, wie Sie es später benötigen.
Kapitel 2 – Verwenden der UWP-Anwendung "Person Maker"
Stellen Sie sicher, dass Sie die vorgefertigte UWP-Anwendung namens Person Maker herunterladen. Diese App ist nicht das Endprodukt für diesen Kurs, nur ein Tool, mit dem Sie Ihre Azure-Einträge erstellen können, auf die sich das spätere Projekt stützt.
Person Maker ermöglicht Ihnen das Erstellen von Azure-Einträgen, die Personen und Personengruppen zugeordnet sind. Die Anwendung platziert alle erforderlichen Informationen in einem Format, das später von der FaceAPI verwendet werden kann, um die Gesichter von Personen zu erkennen, die Sie hinzugefügt haben.
[WICHTIG] Person Maker verwendet einige grundlegende Einschränkungen, um sicherzustellen, dass Sie die Anzahl der Serviceanrufe pro Minute für die kostenlose Abonnementebene nicht überschreiten. Der grüne Text oben ändert sich in Rot und wird beim Drosseln als "AKTIV" aktualisiert. Wenn dies der Fall ist, warten Sie einfach auf die Anwendung (es wartet, bis sie weiter auf den Gesichtsdienst zugreifen kann, wird als "IN-ACTIVE" aktualisiert, wenn Sie sie erneut verwenden können).
Diese Anwendung verwendet die Microsoft.ProjectOxford.Face-Bibliotheken , mit denen Sie die Face-API vollständig nutzen können. Diese Bibliothek ist kostenlos als NuGet-Paket verfügbar. Weitere Informationen dazu und ähnliche APIs stellen sicher, dass Sie den API-Referenzartikel besuchen.
Hinweis
Dies sind nur die erforderlichen Schritte, Anweisungen zum Ausführen dieser Dinge finden Sie weiter unten im Dokument. Die Person Maker-App ermöglicht Folgendes:
Erstellen Sie eine Personengruppe, die aus mehreren Personen besteht, die sie zuordnen möchten. Mit Ihrem Azure-Konto können Sie mehrere Personengruppen hosten.
Erstellen Sie eine Person, die Mitglied einer Personengruppe ist. Jeder Person ist eine Reihe von Gesichtsbildern zugeordnet.
Weisen Sie einer Person Gesichtsbilder zu, damit Ihr Azure Face API-Dienst eine Person anhand des entsprechenden Gesichts erkennen kann.
Schulen Sie Ihren Azure Face API-Dienst.
Beachten Sie, dass Sie diese App so trainieren möchten, dass Sie Personen erkennen können, sie benötigen zehn (10) Nahaufnahmefotos jeder Person, die Sie Ihrer Personengruppe hinzufügen möchten. Die Windows 10 Cam-App kann Ihnen dabei helfen, dies zu erledigen. Sie müssen sicherstellen, dass jedes Foto klar ist (vermeiden Sie unscharf, obscuring oder zu weit vom Betreff), dass das Foto im JPG- oder PNG-Dateiformat vorhanden ist, wobei die Bilddatei nicht größer als 4 MB und nicht kleiner als 1 KB ist.
Hinweis
Wenn Sie diesem Lernprogramm folgen, verwenden Sie nicht Ihr eigenes Gesicht für Schulungen, wie Sie die HoloLens aktivieren, können Sie sich nicht selbst ansehen. Verwenden Sie das Gesicht eines Kollegen oder Kollegen.
Running Person Maker:
Öffnen Sie den Ordner "PersonMaker ", und doppelklicken Sie auf die PersonMaker-Lösung , um ihn mit Visual Studio zu öffnen.
Sobald die PersonMaker-Lösung geöffnet ist, stellen Sie sicher, dass:
Die Lösungskonfiguration ist auf " Debuggen" festgelegt.
Die Lösungsplattform ist auf x86 festgelegt.
Die Zielplattform ist ein lokaler Computer.
Möglicherweise müssen Sie auch NuGet-Pakete wiederherstellen (klicken Sie mit der rechten Maustaste auf die Lösung, und wählen Sie "NuGet-Pakete wiederherstellen" aus).
Klicken Sie auf "Lokaler Computer ", und die Anwendung wird gestartet. Beachten Sie, dass auf kleineren Bildschirmen möglicherweise nicht alle Inhalte sichtbar sind, obwohl Sie weiter nach unten scrollen können, um sie anzuzeigen.
Fügen Sie Ihren Azure-Authentifizierungsschlüssel aus Ihrem Face-API-Dienst in Azure ein.
Einfügen:
- Die ID , die Sie der Personengruppe zuweisen möchten. Die ID muss klein geschrieben sein, ohne Leerzeichen. Notieren Sie sich diese ID, da sie später in Ihrem Unity-Projekt erforderlich ist.
- Der Name , den Sie der Personengruppe zuweisen möchten (kann Leerzeichen aufweisen).
Drücken Sie die Schaltfläche "Personengruppe erstellen". Unter der Schaltfläche sollte eine Bestätigungsmeldung angezeigt werden.
Hinweis
Wenn sie einen Fehler "Zugriff verweigert" haben, überprüfen Sie den Speicherort, den Sie für Ihren Azure-Dienst festgelegt haben. Wie oben erwähnt, ist diese App für "West-US" konzipiert.
Wichtig
Sie werden feststellen, dass Sie auch auf die Schaltfläche "Bekannte Gruppe abrufen" klicken können: Dies gilt, wenn Sie bereits eine Personengruppe erstellt haben und dies verwenden möchten, anstatt eine neue Gruppe zu erstellen. Beachten Sie folgendes: Wenn Sie auf "Personengruppe mit einer bekannten Gruppe erstellen" klicken, ruft dies auch eine Gruppe ab.
Fügen Sie den Namen der Person ein, die Sie erstellen möchten.
Klicken Sie auf die Schaltfläche "Person erstellen".
Unter der Schaltfläche sollte eine Bestätigungsmeldung angezeigt werden.
Wenn Sie eine person löschen möchten, die Sie zuvor erstellt haben, können Sie den Namen in das Textfeld schreiben und die ENTF-Person drücken .
Stellen Sie sicher, dass Sie den Speicherort von zehn (10) Fotos der Person kennen, die Sie Ihrer Gruppe hinzufügen möchten.
Drücken Sie "Erstellen" und "Ordner öffnen", um Den Windows-Explorer mit dem Ordner zu öffnen, der der Person zugeordnet ist. Fügen Sie die zehn (10) Bilder im Ordner hinzu. Dies muss ein JPG - oder PNG-Dateiformat sein.
Klicken Sie auf " An Azure übermitteln". Ein Indikator zeigt Ihnen den Status der Übermittlung, gefolgt von einer Nachricht, wenn sie abgeschlossen ist.
Sobald der Zähler abgeschlossen ist und eine Bestätigungsmeldung angezeigt wurde, klicken Sie auf "Trainieren ", um Ihren Dienst zu trainieren.
Sobald der Prozess abgeschlossen ist, können Sie in Unity wechseln.
Kapitel 3 – Einrichten des Unity-Projekts
Im Folgenden sehen Sie eine typische Einrichtung für die Entwicklung mit Mixed Reality und ist daher eine gute Vorlage für andere Projekte.
Öffnen Sie Unity , und klicken Sie auf "Neu".
Sie müssen nun einen Unity-Projektnamen angeben. Fügen Sie MR_FaceRecognition ein. Stellen Sie sicher, dass der Projekttyp auf 3D festgelegt ist. Legen Sie den Speicherort an einer für Sie geeigneten Stelle fest (denken Sie daran, dass die Stammverzeichnisse besser sind). Klicken Sie dann auf "Projekt erstellen".
Wenn Unity geöffnet ist, lohnt es sich, den Standardmäßigen Skript-Editor auf Visual Studio festzulegen. Wechseln Sie zu "Einstellungen bearbeiten>", 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 als Nächstes zu "Dateibuildeinstellungen>", und wechseln Sie zur Plattform zu Universelle Windows-Plattform, indem Sie auf die Schaltfläche "Plattform wechseln" klicken.
Wechseln Sie zu " Dateibuildeinstellungen > " , und stellen Sie sicher, dass:
Zielgerät ist auf HoloLens festgelegt
Legen Sie für die immersiven Headsets "Zielgerät " auf "Jedes Gerät" fest.
Buildtyp ist auf D3D festgelegt
SDK ist auf "Neueste Installation" festgelegt.
Visual Studio-Version ist auf "Neueste Installation" festgelegt.
Build und Ausführung ist auf den lokalen 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.
Wählen Sie die Schaltfläche "Neuer Ordner " aus, um einen neuen Ordner zu erstellen, nennen Sie ihn "Szenen".
Öffnen Sie den neu erstellten Ordner "Szenen", und drücken Sie dann im Feld "Dateiname: Textfeld", "FaceRecScene" ein, und drücken Sie dann "Speichern".
Die übrigen Einstellungen in den Buildeinstellungen sollten jetzt als Standard beibehalten werden.
Klicken Sie im Fenster "Buildeinstellungen " auf die Schaltfläche "Spielereinstellungen ". Dadurch wird der zugehörige Bereich im Bereich geöffnet, in dem sich der Inspektor befindet.
In diesem Bereich müssen einige Einstellungen überprüft werden:
Auf der Registerkarte "Andere Einstellungen" folgendes:
Die Skripting-Runtime-Version sollte experimentell sein (.NET 4.6-Entsprechung). Wenn Sie dies ändern, wird ein Neustart des Editors ausgelöst.
Scripting Back-End sollte .NET sein
API-Kompatibilitätsstufe sollte .NET 4.6 sein
Aktivieren Sie auf der Registerkarte "Veröffentlichungseinstellungen " unter "Funktionen" Folgendes:
InternetClient
Webcam
Klicken Sie weiter unten im Bereich unter "XR-Einstellungen" (unter "Veröffentlichungseinstellungen" finden Sie auf "Virtual Reality Unterstützt"), und vergewissern Sie sich, dass das Windows Mixed Reality SDK hinzugefügt wird.
Zurück in build settings, Unity C# Projects is no longer greyed out; tick the checkbox next to this.
Schließen Sie das Fenster Buildeinstellungen.
Speichern Sie Ihre Szene und Ihr Projekt (FILE > SAVE SCENE / FILE > SAVE PROJECT).
Kapitel 4 – Einrichtung der Hauptkamera
Wichtig
Wenn Sie die Unity Set up-Komponente dieses Kurses überspringen und direkt in Code fortfahren möchten, können Sie dieses Unitypackage herunterladen und in Ihr Projekt als benutzerdefiniertes Paket importieren. Beachten Sie, dass dieses Paket auch den Import der Newtonsoft-DLL enthält, die in Kapitel 5 behandelt wird. Mit diesem Importierten können Sie ab Kapitel 6 fortfahren.
Wählen Sie im Hierarchiebereich die Hauptkamera aus.
Nach der Auswahl können Sie alle Komponenten der Hauptkamera im Inspektorbereich anzeigen.
Das Camera-Objekt muss die Hauptkamera genannt werden (beachten Sie die Schreibweise!)
Das Hauptkameratag muss auf "MainCamera" festgelegt werden (beachten Sie die Schreibweise!)
Stellen Sie sicher, dass die Transformationsposition auf 0, 0, 0 festgelegt ist.
Festlegen von Clear Flags auf Volltonfarbe
Festlegen der Hintergrundfarbe der Kamerakomponente auf Schwarz, Alpha 0 (Hex-Code: #00000000)
Kapitel 5 – Importieren der Newtonsoft.Json-Bibliothek
Wichtig
Wenn Sie das ".unitypackage" im letzten Kapitel importiert haben, können Sie dieses Kapitel überspringen.
Damit Sie Objekte deserialisieren und serialisieren können, die empfangen und an den Bot-Dienst gesendet werden, müssen Sie die Newtonsoft.Json-Bibliothek herunterladen. Sie finden eine kompatible Version, die bereits mit der richtigen Unity-Ordnerstruktur in dieser Unity-Paketdatei organisiert ist.
So importieren Sie die Bibliothek:
Laden Sie das Unity-Paket herunter.
Klicken Sie auf "Objekte", "Paket importieren", "Benutzerdefiniertes Paket".
Suchen Sie nach dem Unity-Paket, das Sie heruntergeladen haben, und klicken Sie auf "Öffnen".
Stellen Sie sicher, dass alle Komponenten des Pakets markiert sind, und klicken Sie auf " Importieren".
Kapitel 6 – Erstellen der FaceAnalysis-Klasse
Der Zweck der FaceAnalysis-Klasse besteht darin, die methoden zu hosten, die für die Kommunikation mit Ihrem Azure-Gesichtserkennungsdienst erforderlich sind.
- Nach dem Senden des Diensts wird es ein Aufnahmebild analysieren und die Gesichter identifizieren und bestimmen, ob einer bekannten Person gehört.
- Wenn eine bekannte Person gefunden wird, zeigt diese Klasse ihren Namen als UI-Text in der Szene an.
So erstellen Sie die FaceAnalysis-Klasse :
Klicken Sie mit der rechten Maustaste auf den Ordner "Objekte" im Projektbereich, 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 auf "C#-Skript erstellen>". Rufen Sie das Skript FaceAnalysis auf.
Doppelklicken Sie auf das neue FaceAnalysis-Skript , um es mit Visual Studio 2017 zu öffnen.
Geben Sie die folgenden Namespaces oberhalb der FaceAnalysis-Klasse ein:
using Newtonsoft.Json; using System.Collections; using System.Collections.Generic; using System.IO; using System.Text; using UnityEngine; using UnityEngine.Networking;Jetzt müssen Sie alle Objekte hinzufügen, die zum Deserialisieren verwendet werden. Diese Objekte müssen außerhalb des FaceAnalysis-Skripts (unter der unteren geschweiften Klammer) hinzugefügt werden.
/// <summary> /// The Person Group object /// </summary> public class Group_RootObject { public string personGroupId { get; set; } public string name { get; set; } public object userData { get; set; } } /// <summary> /// The Person Face object /// </summary> public class Face_RootObject { public string faceId { get; set; } } /// <summary> /// Collection of faces that needs to be identified /// </summary> public class FacesToIdentify_RootObject { public string personGroupId { get; set; } public List<string> faceIds { get; set; } public int maxNumOfCandidatesReturned { get; set; } public double confidenceThreshold { get; set; } } /// <summary> /// Collection of Candidates for the face /// </summary> public class Candidate_RootObject { public string faceId { get; set; } public List<Candidate> candidates { get; set; } } public class Candidate { public string personId { get; set; } public double confidence { get; set; } } /// <summary> /// Name and Id of the identified Person /// </summary> public class IdentifiedPerson_RootObject { public string personId { get; set; } public string name { get; set; } }Die Methoden Start() und Update() werden nicht verwendet, daher löschen Sie sie jetzt.
Fügen Sie in der FaceAnalysis-Klasse die folgenden Variablen hinzu:
/// <summary> /// Allows this class to behave like a singleton /// </summary> public static FaceAnalysis Instance; /// <summary> /// The analysis result text /// </summary> private TextMesh labelText; /// <summary> /// Bytes of the image captured with camera /// </summary> internal byte[] imageBytes; /// <summary> /// Path of the image captured with camera /// </summary> internal string imagePath; /// <summary> /// Base endpoint of Face Recognition Service /// </summary> const string baseEndpoint = "https://westus.api.cognitive.microsoft.com/face/v1.0/"; /// <summary> /// Auth key of Face Recognition Service /// </summary> private const string key = "- Insert your key here -"; /// <summary> /// Id (name) of the created person group /// </summary> private const string personGroupId = "- Insert your group Id here -";Hinweis
Ersetzen Sie den Schlüssel und die personGroupId durch Ihren Dienstschlüssel und die ID der Gruppe, die Sie zuvor erstellt haben.
Fügen Sie die Awake()- Methode hinzu, die die Klasse initialisiert, die ImageCapture-Klasse zur Hauptkamera hinzufügt und die Bezeichnungserstellungsmethode aufruft:
/// <summary> /// Initialises this class /// </summary> private void Awake() { // Allows this instance to behave like a singleton Instance = this; // Add the ImageCapture Class to this Game Object gameObject.AddComponent<ImageCapture>(); // Create the text label in the scene CreateLabel(); }Fügen Sie die CreateLabel() -Methode hinzu, mit der das Label-Objekt erstellt wird, um das Analyseergebnis anzuzeigen:
/// <summary> /// Spawns cursor for the Main Camera /// </summary> private void CreateLabel() { // Create a sphere as new cursor GameObject newLabel = new GameObject(); // Attach the label to the Main Camera newLabel.transform.parent = gameObject.transform; // Resize and position the new cursor newLabel.transform.localScale = new Vector3(0.4f, 0.4f, 0.4f); newLabel.transform.position = new Vector3(0f, 3f, 60f); // Creating the text of the Label labelText = newLabel.AddComponent<TextMesh>(); labelText.anchor = TextAnchor.MiddleCenter; labelText.alignment = TextAlignment.Center; labelText.tabSize = 4; labelText.fontSize = 50; labelText.text = "."; }Fügen Sie die Methode DetectFacesFromImage() und GetImageAsByteArray() hinzu. Der erste fordert den Gesichtserkennungsdienst auf, alle möglichen Gesichts im übermittelten Bild zu erkennen, während letzteres erforderlich ist, um das aufgenommene Bild in ein Bytearray zu konvertieren:
/// <summary> /// Detect faces from a submitted image /// </summary> internal IEnumerator DetectFacesFromImage() { WWWForm webForm = new WWWForm(); string detectFacesEndpoint = $"{baseEndpoint}detect"; // Change the image into a bytes array imageBytes = GetImageAsByteArray(imagePath); using (UnityWebRequest www = UnityWebRequest.Post(detectFacesEndpoint, webForm)) { www.SetRequestHeader("Ocp-Apim-Subscription-Key", key); www.SetRequestHeader("Content-Type", "application/octet-stream"); www.uploadHandler.contentType = "application/octet-stream"; www.uploadHandler = new UploadHandlerRaw(imageBytes); www.downloadHandler = new DownloadHandlerBuffer(); yield return www.SendWebRequest(); string jsonResponse = www.downloadHandler.text; Face_RootObject[] face_RootObject = JsonConvert.DeserializeObject<Face_RootObject[]>(jsonResponse); List<string> facesIdList = new List<string>(); // Create a list with the face Ids of faces detected in image foreach (Face_RootObject faceRO in face_RootObject) { facesIdList.Add(faceRO.faceId); Debug.Log($"Detected face - Id: {faceRO.faceId}"); } StartCoroutine(IdentifyFaces(facesIdList)); } } /// <summary> /// Returns the contents of the specified 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); }Fügen Sie die IdentifyFaces()- Methode hinzu, die den Gesichtserkennungsdienst anfordert, alle bekannten Gesichtserkennungen zu identifizieren, die zuvor im übermittelten Bild erkannt wurden. Die Anforderung gibt eine ID der identifizierten Person, aber nicht den Namen zurück:
/// <summary> /// Identify the faces found in the image within the person group /// </summary> internal IEnumerator IdentifyFaces(List<string> listOfFacesIdToIdentify) { // Create the object hosting the faces to identify FacesToIdentify_RootObject facesToIdentify = new FacesToIdentify_RootObject(); facesToIdentify.faceIds = new List<string>(); facesToIdentify.personGroupId = personGroupId; foreach (string facesId in listOfFacesIdToIdentify) { facesToIdentify.faceIds.Add(facesId); } facesToIdentify.maxNumOfCandidatesReturned = 1; facesToIdentify.confidenceThreshold = 0.5; // Serialize to Json format string facesToIdentifyJson = JsonConvert.SerializeObject(facesToIdentify); // Change the object into a bytes array byte[] facesData = Encoding.UTF8.GetBytes(facesToIdentifyJson); WWWForm webForm = new WWWForm(); string detectFacesEndpoint = $"{baseEndpoint}identify"; using (UnityWebRequest www = UnityWebRequest.Post(detectFacesEndpoint, webForm)) { www.SetRequestHeader("Ocp-Apim-Subscription-Key", key); www.SetRequestHeader("Content-Type", "application/json"); www.uploadHandler.contentType = "application/json"; www.uploadHandler = new UploadHandlerRaw(facesData); www.downloadHandler = new DownloadHandlerBuffer(); yield return www.SendWebRequest(); string jsonResponse = www.downloadHandler.text; Debug.Log($"Get Person - jsonResponse: {jsonResponse}"); Candidate_RootObject [] candidate_RootObject = JsonConvert.DeserializeObject<Candidate_RootObject[]>(jsonResponse); // For each face to identify that ahs been submitted, display its candidate foreach (Candidate_RootObject candidateRO in candidate_RootObject) { StartCoroutine(GetPerson(candidateRO.candidates[0].personId)); // Delay the next "GetPerson" call, so all faces candidate are displayed properly yield return new WaitForSeconds(3); } } }Fügen Sie die GetPerson()- Methode hinzu. Durch Die Angabe der Personen-ID fordert diese Methode dann an, dass der Gesichtserkennungsdienst den Namen der identifizierten Person zurückgibt:
/// <summary> /// Provided a personId, retrieve the person name associated with it /// </summary> internal IEnumerator GetPerson(string personId) { string getGroupEndpoint = $"{baseEndpoint}persongroups/{personGroupId}/persons/{personId}?"; WWWForm webForm = new WWWForm(); using (UnityWebRequest www = UnityWebRequest.Get(getGroupEndpoint)) { www.SetRequestHeader("Ocp-Apim-Subscription-Key", key); www.downloadHandler = new DownloadHandlerBuffer(); yield return www.SendWebRequest(); string jsonResponse = www.downloadHandler.text; Debug.Log($"Get Person - jsonResponse: {jsonResponse}"); IdentifiedPerson_RootObject identifiedPerson_RootObject = JsonConvert.DeserializeObject<IdentifiedPerson_RootObject>(jsonResponse); // Display the name of the person in the UI labelText.text = identifiedPerson_RootObject.name; } }Denken Sie daran, die Änderungen zu speichern , bevor Sie zum Unity-Editor zurückkehren.
Ziehen Sie im Unity-Editor das FaceAnalysis-Skript aus dem Ordner "Skripts" im Projektbereich auf das Hauptkameraobjekt im Hierarchiebereich. Die neue Skriptkomponente wird der Hauptkamera hinzugefügt.
Kapitel 7 – Erstellen der ImageCapture-Klasse
Der Zweck der ImageCapture-Klasse besteht darin, die Methoden zu hosten, die erforderlich sind, um mit Ihrem Azure-Gesichtserkennungsdienst zu kommunizieren, um das Bild zu analysieren, das Sie erfassen, Gesichter darin identifizieren und bestimmen, ob sie zu einer bekannten Person gehört. Wenn eine bekannte Person gefunden wird, zeigt diese Klasse ihren Namen als UI-Text in der Szene an.
So erstellen Sie die ImageCapture-Klasse :
Klicken Sie mit der rechten Maustaste in den Ordner "Skripts", den Sie zuvor erstellt haben, und klicken Sie dann auf "Erstellen", "C#-Skript". Rufen Sie das Skript ImageCapture auf.
Doppelklicken Sie auf das neue ImageCapture-Skript , um es mit Visual Studio 2017 zu öffnen.
Geben Sie die folgenden Namespaces oberhalb der ImageCapture-Klasse ein:
using System.IO; using System.Linq; using UnityEngine; using UnityEngine.XR.WSA.Input; using UnityEngine.XR.WSA.WebCam;Fügen Sie innerhalb der ImageCapture-Klasse die folgenden Variablen hinzu:
/// <summary> /// Allows this class to behave like a singleton /// </summary> public static ImageCapture instance; /// <summary> /// Keeps track of tapCounts to name the captured images /// </summary> private int tapsCount; /// <summary> /// PhotoCapture object used to capture images on HoloLens /// </summary> private PhotoCapture photoCaptureObject = null; /// <summary> /// HoloLens class to capture user gestures /// </summary> private GestureRecognizer recognizer;Fügen Sie die Methoden Awake() und Start() hinzu, die zum Initialisieren der Klasse erforderlich sind, und ermöglichen Sie es holoLens, die Gesten des Benutzers zu erfassen:
/// <summary> /// Initialises this class /// </summary> private void Awake() { instance = this; } /// <summary> /// Called right after Awake /// </summary> void Start() { // Initialises user gestures capture recognizer = new GestureRecognizer(); recognizer.SetRecognizableGestures(GestureSettings.Tap); recognizer.Tapped += TapHandler; recognizer.StartCapturingGestures(); }Fügen Sie den TapHandler() hinzu, der aufgerufen wird, wenn der Benutzer eine Tippgeste ausführt:
/// <summary> /// Respond to Tap Input. /// </summary> private void TapHandler(TappedEventArgs obj) { tapsCount++; ExecuteImageCaptureAndAnalysis(); }Fügen Sie die ExecuteImageCaptureAndAnalysis() -Methode hinzu, die mit dem Prozess der Bildaufnahme beginnt:
/// <summary> /// Begin process of Image Capturing and send To Azure Computer Vision service. /// </summary> private void ExecuteImageCaptureAndAnalysis() { Resolution cameraResolution = PhotoCapture.SupportedResolutions.OrderByDescending ((res) => res.width * res.height).First(); Texture2D targetTexture = new Texture2D(cameraResolution.width, cameraResolution.height); PhotoCapture.CreateAsync(false, delegate (PhotoCapture captureObject) { photoCaptureObject = captureObject; CameraParameters c = new CameraParameters(); c.hologramOpacity = 0.0f; c.cameraResolutionWidth = targetTexture.width; c.cameraResolutionHeight = targetTexture.height; c.pixelFormat = CapturePixelFormat.BGRA32; captureObject.StartPhotoModeAsync(c, delegate (PhotoCapture.PhotoCaptureResult result) { string filename = string.Format(@"CapturedImage{0}.jpg", tapsCount); string filePath = Path.Combine(Application.persistentDataPath, filename); // Set the image path on the FaceAnalysis class FaceAnalysis.Instance.imagePath = filePath; photoCaptureObject.TakePhotoAsync (filePath, PhotoCaptureFileOutputFormat.JPG, OnCapturedPhotoToDisk); }); }); }Fügen Sie die Handler hinzu, die aufgerufen werden, wenn der Fotoaufnahmevorgang abgeschlossen wurde:
/// <summary> /// Called right after the photo capture process has concluded /// </summary> void OnCapturedPhotoToDisk(PhotoCapture.PhotoCaptureResult result) { photoCaptureObject.StopPhotoModeAsync(OnStoppedPhotoMode); } /// <summary> /// Register the full execution of the Photo Capture. If successful, it will begin the Image Analysis process. /// </summary> void OnStoppedPhotoMode(PhotoCapture.PhotoCaptureResult result) { photoCaptureObject.Dispose(); photoCaptureObject = null; // Request image caputer analysis StartCoroutine(FaceAnalysis.Instance.DetectFacesFromImage()); }Denken Sie daran, die Änderungen zu speichern , bevor Sie zum Unity-Editor zurückkehren.
Kapitel 8 – Erstellen der Lösung
Um einen gründlichen Test Ihrer Anwendung durchzuführen, müssen Sie sie auf Ihre HoloLens querladen.
Bevor Sie vorgehen, stellen Sie folgendes sicher:
- Alle im Kapitel 3 genannten Einstellungen sind korrekt festgelegt.
- Das Skript FaceAnalysis ist an das Hauptkameraobjekt angefügt.
- Sowohl der Authentifizierungsschlüssel als auch die Gruppen-ID wurden im FaceAnalysis-Skript festgelegt.
An diesem Punkt können Sie die Lösung erstellen. Nachdem die Lösung erstellt wurde, können Sie Ihre Anwendung bereitstellen.
So beginnen Sie den Buildprozess:
Speichern Sie die aktuelle Szene, indem Sie auf "Datei", "Speichern" klicken.
Wechseln Sie zu "Datei", "Buildeinstellungen", klicken Sie auf "Offene Szenen hinzufügen".
Stellen Sie sicher, dass Sie "Unity C#-Projekte" markieren.
Drücken Sie Build. Auf diese Weise startet Unity ein Explorer-Fenster, in dem Sie einen Ordner erstellen und dann einen Ordner auswählen müssen, in dem die App erstellt werden soll. Erstellen Sie diesen Ordner jetzt im Unity-Projekt, und rufen Sie ihn als App auf. Drücken Sie dann mit ausgewähltem App-Ordner "Ordner auswählen".
Unity beginnt mit dem Erstellen Ihres Projekts, aus dem App-Ordner heraus.
Nachdem Unity das Erstellen abgeschlossen hat (es kann einige Zeit dauern), wird ein Explorer Fenster am Speicherort Ihres Builds geöffnet.
Öffnen Sie Ihren App-Ordner, und öffnen Sie dann die neue Projektmappe (siehe oben MR_FaceRecognition.sln).
Kapitel 9 – Bereitstellen Der Anwendung
So stellen Sie holoLens bereit:
Sie benötigen die IP-Adresse Ihrer HoloLens (für Remotebereitstellung) und um sicherzustellen, dass Sich Ihre HoloLens im Entwicklermodus befindet. Gehen Sie hierzu folgendermaßen vor:
- Öffnen Sie beim Tragen Ihrer HoloLens die Einstellungen.
- Wechseln sie zu den erweiterten Optionen für Netzwerk- und Internet-WLAN > >
- Notieren Sie sich die IPv4-Adresse .
- Navigieren Sie als Nächstes zurück zu "Einstellungen" und dann zu "Update & Sicherheit > für Entwickler".
- Legen Sie den Entwicklermodus aktiviert fest.
Navigieren Sie zu Ihrem neuen Unity-Build (dem App-Ordner ), und öffnen Sie die Projektmappendatei mit Visual Studio.
Wählen Sie in der Lösungskonfiguration "Debuggen" aus.
Wählen Sie in der Lösungsplattform x86, Remotecomputer aus.
Wechseln Sie zum Menü " Erstellen", und klicken Sie auf "Lösung bereitstellen", um die Anwendung in Ihre HoloLens querzuladen.
Ihre App sollte jetzt in der Liste der installierten Apps auf Ihrer HoloLens angezeigt werden und kann gestartet werden!
Hinweis
Um das immersive Headset bereitzustellen, legen Sie die Lösungsplattform auf den lokalen Computer fest, und legen Sie die Konfiguration auf "Debuggen" fest, wobei x86 als Plattform verwendet wird. Stellen Sie dann mithilfe des Menüs "Erstellen" die Option "Lösung bereitstellen" auf dem lokalen Computer bereit.
Kapitel 10 – Verwenden der Anwendung
Starten Sie die App mit holoLens.
Sehen Sie sich die Person an, die Sie bei der Face-API registriert haben. Stellen Sie Folgendes sicher:
- Das Gesicht der Person ist nicht zu weit und deutlich sichtbar
- Die Umgebungsbeleuchtung ist nicht zu dunkel
Verwenden Sie die Tippbewegung, um das Bild der Person zu erfassen.
Warten Sie, bis die App die Analyseanforderung sendet und eine Antwort empfängt.
Wenn die Person erfolgreich erkannt wurde, wird der Name der Person als UI-Text angezeigt.
Sie können den Aufnahmevorgang mit der Tippbewegung alle paar Sekunden wiederholen.
Ihre fertige Azure Face API-Anwendung
Herzlichen Glückwunsch, Sie haben eine Mixed Reality-App erstellt, die den Azure-Gesichtserkennungsdienst nutzt, um Gesichter innerhalb eines Bilds zu erkennen und bekannte Gesichter zu identifizieren.
Zusatzübungen
Übung 1
Die Azure Face API ist leistungsfähig genug, um bis zu 64 Gesichter in einem einzelnen Bild zu erkennen. Erweitern Sie die Anwendung, damit sie zwei oder drei Gesichter unter vielen anderen Personen erkennen kann.
Übung 2
Die Azure Face-API kann auch alle Arten von Attributinformationen zurückgeben. Integrieren Sie dies in die Anwendung. Dies könnte noch interessanter sein, wenn sie mit der Emotion-API kombiniert wird.