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 Tutorials geben, die in Zukunft veröffentlicht werden, die zeigen, wie für HoloLens 2 entwickelt werden kann. Dieser Hinweis wird mit einem Link zu diesen Tutorials 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-Gesichtserkennungs-API Gesichtserkennungsfunktionen hinzufügen.
Die Azure Face-API ist ein Microsoft-Dienst, der Entwicklern die fortschrittlichsten Gesichtsalgorithmen in der Cloud bietet. Die Gesichtserkennungs-API verfügt über zwei Standard Funktionen: Gesichtserkennung mit Attributen und Gesichtserkennung. Dadurch können Entwickler einfach eine Gruppe von Gruppen für Gesichter festlegen und später Abfragebilder an den Dienst senden, um zu bestimmen, zu wem ein Gesicht gehört. Weitere Informationen finden Sie auf der Seite Zur Azure-Gesichtserkennung.
Nach Abschluss dieses Kurses verfügen Sie über eine Mixed Reality HoloLens-Anwendung, die folgendes ausführen kann:
- Verwenden Sie eine Tippen-Geste , um die Aufnahme eines Bilds mithilfe der onboard HoloLens-Kamera zu initiieren.
- Senden Sie das erfasste Image an den Azure Face API-Dienst .
- Erhalten Sie die Ergebnisse des Gesichtserkennungs-API-Algorithmus .
- Verwenden Sie eine einfache Benutzeroberfläche, um den Namen der übereinstimmenden Personen anzuzeigen.
Dadurch erfahren Sie, wie Sie die Ergebnisse aus dem Gesichtserkennungs-API-Dienst in Ihre Unity-basierte Mixed Reality-Anwendung abrufen.
In Ihrer Anwendung liegt es bei Ihnen, wie Sie die Ergebnisse in Ihr Design integrieren. In diesem Kurs erfahren Sie, wie Sie einen Azure-Dienst in Ihr Unity-Projekt integrieren. Es ist Ihre Aufgabe, das Wissen, das Sie aus diesem Kurs gewinnen, zu nutzen, um Ihre Mixed Reality-Anwendung zu verbessern.
Geräteunterstützung
| Kurs | HoloLens | Immersive Headsets |
|---|---|---|
| MR und Azure 304: Gesichtserkennung | ✔️ | ✔️ |
Hinweis
Während sich dieser Kurs hauptsächlich auf HoloLens konzentriert, können Sie das, was Sie in diesem Kurs lernen, auch auf Windows Mixed Reality immersiven (VR)-Headsets anwenden. Da immersive Headsets (VR) keine zugänglichen Kameras haben, benötigen Sie eine externe Kamera, die an Ihren PC angeschlossen ist. Während Sie den Kurs befolgen, werden Ihnen Notizen zu allen Änderungen angezeigt, die Sie möglicherweise anwenden müssen, um immersive Headsets (VR) 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 des Schreibens (Mai 2018) getestet und überprüft wurde. Sie können die neueste Software verwenden, wie im Artikel Installieren der Tools aufgeführt, aber es sollte nicht davon ausgegangen werden, dass die Informationen in diesem Kurs perfekt dem entsprechen, was Sie in neuerer Software finden, als die unten aufgeführten.
Wir empfehlen die folgende Hard- 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 aktiviertem Entwicklermodus
- Das neueste Windows 10 SDK
- Unity 2017.4
- Visual Studio 2017
- Ein Windows Mixed Reality immersives Headset (VR) oder Microsoft HoloLens mit aktiviertem Entwicklermodus
- Eine Kamera, die an Ihren PC angeschlossen ist (für die Entwicklung immersiver Headsets)
- Internetzugriff für Azure-Setup und Gesichtserkennungs-API
Vorbereitung
- Um Probleme beim Erstellen dieses Projekts zu vermeiden, wird dringend empfohlen, das in diesem Tutorial erwähnte Projekt in einem Stamm- oder Fast-Root-Ordner zu erstellen (lange Ordnerpfade können zur Buildzeit Zu Problemen führen).
- Richten Sie Ihre HoloLens ein und testen Sie sie. Wenn Sie Unterstützung beim Einrichten Ihrer HoloLens benötigen, lesen Sie den Artikel HoloLens-Setup.
- Es ist eine gute Idee, Kalibrierung und Sensoroptimierung durchzuführen, wenn Sie mit der Entwicklung einer neuen HoloLens-App beginnen (manchmal kann dies helfen, diese Aufgaben für jeden Benutzer auszuführen).
Hilfe zur Kalibrierung finden Sie unter diesem Link zum Artikel HoloLens-Kalibrierung.
Hilfe zur Sensoroptimierung finden Sie unter diesem Link zum Artikel HoloLens Sensoroptimierung.
Kapitel 1: Azure-Portal
Um den Gesichtserkennungs-API-Dienst in Azure verwenden zu können, müssen Sie eine instance des Diensts konfigurieren, der für Ihre Anwendung verfügbar gemacht wird.
Melden Sie sich zunächst beim Azure-Portal an.
Hinweis
Wenn Sie noch nicht über ein Azure-Konto verfügen, müssen Sie ein Azure-Konto erstellen. Wenn Sie dieses Tutorial in einer Unterrichts- oder Labsituation befolgen, bitten Sie Ihren Kursleiter oder einen der Verantwortlichen um Hilfe beim Einrichten Ihres neuen Kontos.
Nachdem Sie angemeldet sind, klicken Sie in der oberen linken Ecke auf Neu , und suchen Sie nach Gesichtserkennungs-API, und drücken Sie die EINGABETASTE.
Hinweis
Das Wort Neu wurde in neueren Portalen möglicherweise durch Ressource erstellen ersetzt.
Die neue Seite enthält eine Beschreibung des Gesichtserkennungs-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 den gewünschten Namen für diesen Dienst instance ein.
Wählen Sie ein Abonnement aus.
Wählen Sie den für Sie geeigneten Tarif aus. Wenn Sie zum ersten Mal einen Gesichtserkennungs-API-Dienst erstellen, sollte Ihnen ein kostenloser Tarif (F0) zur Verfügung stehen.
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-Dienste, die einem einzelnen Projekt (z. B. diesen Labs) zugeordnet sind, unter einer gemeinsamen Ressourcengruppe zu halten.
Wenn Sie mehr über Azure-Ressourcengruppen erfahren möchten, lesen Sie den Artikel Ressourcengruppe.
Die UWP-App Person Maker, die Sie später verwenden, erfordert die Verwendung von "USA, Westen" als Standort.
Sie müssen auch bestätigen, dass Sie die für diesen Dienst geltenden 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.
Eine Benachrichtigung wird im Portal angezeigt, sobald der Dienst instance erstellt wurde.
Klicken Sie auf die Benachrichtigungen, um Ihre neue Dienst-instance zu erkunden.
Wenn Sie bereit sind, klicken Sie in der Benachrichtigung auf Die Schaltfläche Zu Ressource wechseln, um Ihre neue Dienst-instance zu erkunden.
In diesem Tutorial muss Ihre Anwendung Aufrufe an Ihren Dienst tätigen, was mithilfe des Abonnementschlüssels Ihres Diensts erfolgt. Auf der Schnellstartseite Ihres Gesichtserkennungs-API-Diensts ist der erste Punkt Nummer 1, um Ihre Schlüssel zu erhalten.
Wählen Sie auf der Seite Dienst entweder den blauen Link Schlüssel (falls auf der Schnellstartseite) oder den Link Schlüssel im Navigationsmenü der Dienste (links, gekennzeichnet durch das Symbol "Schlüssel") aus, um Ihre Schlüssel anzuzeigen.
Hinweis
Notieren Sie sich einen der Schlüssel, und schützen Sie ihn, da Sie ihn später benötigen.
Kapitel 2: Verwenden der UWP-Anwendung "Person Maker"
Laden Sie unbedingt die vordefinierte UWP-Anwendung mit dem Namen Person Maker herunter. Diese App ist nicht das Endprodukt für diesen Kurs, nur ein Tool, mit dem Sie Ihre Azure-Einträge erstellen können, auf das das spätere Projekt angewiesen ist.
Mit Person Maker können Sie Azure-Einträge erstellen, 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 eine grundlegende Drosselung, um sicherzustellen, dass Sie die Anzahl der Dienstanrufe pro Minute für den kostenlosen Abonnementtarif nicht überschreiten. Der grüne Text am oberen Rand ändert sich in Rot und wird als "ACTIVE" aktualisiert, wenn die Einschränkung stattfindet. wenn dies der Fall ist, warten Sie einfach auf die Anwendung (sie wartet, bis sie als nächstes weiter auf den Gesichtserkennungsdienst zugreifen kann, und wird als "IN-ACTIVE" aktualisiert, wenn Sie sie erneut verwenden können).
Diese Anwendung verwendet die Microsoft.ProjectOxford.Face-Bibliotheken , mit denen Sie die Gesichtserkennungs-API vollständig nutzen können. Diese Bibliothek ist kostenlos als NuGet-Paket verfügbar. Weitere Informationen hierzu und ähnliche APIs finden Sie im Artikel API-Referenz.
Hinweis
Dies sind nur die erforderlichen Schritte. Anweisungen für diese Dinge finden Sie weiter unten im Dokument. Mit der Person Maker-App können Sie Folgendes ausführen:
Erstellen Sie eine Personengruppe, bei der es sich um eine Gruppe handelt, die aus mehreren Personen besteht, die Sie ihr zuordnen möchten. Mit Ihrem Azure-Konto können Sie mehrere Personengruppen hosten.
Erstellen Sie eine Person, die Mitglied einer Personengruppe ist. Jeder Person sind mehrere Gesichtsbilder zugeordnet.
Weisen Sie einer PersonGesichtsbilder zu, damit Ihr Azure Face API Service eine Person anhand des entsprechenden Gesichts erkennen kann.
Trainieren Sie Ihren Azure-Gesichtserkennungs-API-Dienst.
Beachten Sie, dass Sie also zehn (10) Nahaufnahmefotos von jeder Person benötigen, die Sie Ihrer Personengruppe hinzufügen möchten, um diese App so zu trainieren, dass sie Personen erkennen kann. Die Windows 10 Cam-App kann Ihnen dabei helfen. Sie müssen sicherstellen, dass jedes Foto klar ist (vermeiden Sie verwischen, verschleiern oder zu weit vom Betreff entfernt sein), das Foto im JPG- oder PNG-Dateiformat haben, wobei die Größe der Bilddatei nicht größer als 4 MB und nicht weniger als 1 KB ist.
Hinweis
Wenn Sie dieses Tutorial befolgen, verwenden Sie kein eigenes Gesicht für das Training, da Sie sich beim Aktivieren der HoloLens nicht selbst ansehen können. Verwenden Sie das Gesicht eines Kollegen oder Kommilitonen.
Ausführen von Person Maker:
Öffnen Sie den Ordner PersonMaker , und doppelklicken Sie auf die PersonMaker-Projektmappe , um sie mit Visual Studio zu öffnen.
Stellen Sie nach dem Öffnen der PersonMaker-Lösung Folgendes sicher:
Die Projektmappenkonfiguration ist auf Debuggen festgelegt.
Die Lösungsplattform ist auf x86 festgelegt.
Die Zielplattform ist lokaler Computer.
Möglicherweise müssen Sie auch NuGet-Pakete wiederherstellen (klicken Sie mit der rechten Maustaste auf die Projektmappe , 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 Gesichtserkennungs-API-Dienst in Azure ein.
Insert (Einfügen):
- Die ID , die Sie der Personengruppe zuweisen möchten. Die ID muss Kleinbuchstaben ohne Leerzeichen sein. 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 haben).
Drücken Sie die Schaltfläche Personengruppe erstellen . Unter der Schaltfläche sollte eine Bestätigungsmeldung angezeigt werden.
Hinweis
Wenn sie den 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 "USA, Westen" konzipiert.
Wichtig
Sie werden feststellen, dass Sie auch auf die Schaltfläche Abrufen einer bekannten Gruppe klicken können: Dies ist für, wenn Sie bereits eine Personengruppe erstellt haben und diese verwenden möchten, anstatt eine neue Gruppe zu erstellen. Beachten Sie: Wenn Sie auf Personengruppe mit einer bekannten Gruppe erstellen klicken, wird auch eine Gruppe abgerufen.
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 zuvor erstellte Person löschen möchten, können Sie den Namen in das Textfeld schreiben und auf Person löschen klicken.
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 Ordner erstellen und öffnen, um Windows Explorer dem Ordner zu öffnen, der der Person zugeordnet ist. Fügen Sie die zehn (10) Images im Ordner hinzu. Diese müssen im JPG - oder PNG-Dateiformat vorliegen.
Klicken Sie auf An Azure übermitteln. Ein Zähler zeigt den Status der Übermittlung an, gefolgt von einer Meldung, 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 zu Unity wechseln.
Kapitel 3: Einrichten des Unity-Projekts
Das Folgende ist 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 auf einen für Sie geeigneten Ort fest (denken Sie daran, dass näher an Stammverzeichnissen besser ist). Klicken Sie dann auf Projekt erstellen.
Wenn Unity geöffnet ist, lohnt es sich, zu überprüfen, ob der Standardskript-Editor auf Visual Studio festgelegt ist. Navigieren 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 die Plattform auf 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 Beliebiges Gerät fest.
Buildtyp ist auf D3D festgelegt
SDK ist auf Zuletzt installiert festgelegt.
Visual Studio-Version ist auf Zuletzt installiert 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. Es wird ein Fenster zum Speichern angezeigt.
Wählen Sie die Schaltfläche Neuer Ordner aus, um einen neuen Ordner zu erstellen, nennen Sie ihn Szenen.
Öffnen Sie Ihren neu erstellten Ordner Scenes , und geben Sie dann im Textfeld Dateiname: Den Namen FaceRecScene ein, und drücken Sie dann Speichern.
Die restlichen Einstellungen in Buildeinstellungen sollten vorerst als Standard beibehalten werden.
Klicken Sie im Fenster Buildeinstellungen auf die Schaltfläche Playereinstellungen . Dadurch wird der zugehörige 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 gleichwertig) sein. Wenn Sie dies ändern, müssen Sie den Editor neu starten.
Skript-Back-End sollte .NET sein
API-Kompatibilitätsgrad sollte .NET 4.6 sein
Überprüfen Sie auf der Registerkarte Veröffentlichungseinstellungen unter Funktionen Folgendes:
InternetClient
Webcam
Wählen Sie weiter unten im Bereich unter XR-Einstellungen (unter Veröffentlichungseinstellungen) die Option Virtual Reality Supported (Virtual Reality Supported) aus, stellen Sie sicher, dass das Windows Mixed Reality SDK hinzugefügt wurde.
Zurück in den Buildeinstellungen ist Unity C#-Projekte nicht mehr abgeblendet. aktivieren Sie das Kontrollkästchen neben diesem.
Schließen Sie das Fenster „Build Settings“ (Buildeinstellungen).
Speichern Sie Ihre Szene und Ihr Projekt (FILE > SAVE SCENE / FILE > SAVE PROJECT).
Kapitel 4: Setup der Hauptkamera
Wichtig
Wenn Sie die Unity Set up-Komponente dieses Kurses überspringen und direkt mit dem Code fortfahren möchten, können Sie dieses Unitypackage herunterladen und als benutzerdefiniertes Paket in Ihr Projekt importieren. Beachten Sie, dass dieses Paket auch den Import der Newtonsoft-DLL enthält, die in Kapitel 5 behandelt wird. Mit diesem Import können Sie mit Kapitel 6 fortfahren.
Wählen Sie im Hierarchiebereich die Hauptkamera aus.
Nach der Auswahl können Sie alle Komponenten der Hauptkamera im Inspektorbereich sehen.
Das Camera-Objekt muss den Namen Hauptkamera haben (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
Legen Sie die Hintergrundfarbe der Kamerakomponente auf Schwarz, Alpha 0 (Sechskantcode: #00000000) fest.
Kapitel 5: Importieren der Bibliothek Newtonsoft.Json
Wichtig
Wenn Sie das ".unitypackage" im letzten Kapitel importiert haben, können Sie dieses Kapitel überspringen.
Zum Deserialisieren und Serialisieren von Objekten, die an die Bot Service gesendet werden, müssen Sie die Newtonsoft.Json-Bibliothek herunterladen. In dieser Unity-Paketdatei finden Sie eine kompatible Version, die bereits mit der richtigen Unity-Ordnerstruktur organisiert ist.
So importieren Sie die Bibliothek:
Laden Sie das Unity-Paket herunter.
Klicken Sie auf Ressourcen, 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 aktiviert 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.
- Nachdem der Dienst ein Aufnahmebild gesendet hat, wird es analysiert und die Gesichter darin identifiziert und bestimmt, ob eines zu einer bekannten Person gehört.
- Wenn eine bekannte Person gefunden wird, zeigt diese Klasse ihren Namen als Benutzeroberflächentext in der Szene an.
So erstellen Sie die FaceAnalysis-Klasse :
Klicken Sie mit der rechten Maustaste auf den Ordner Assets im Projektbereich, und klicken Sie dann auf Ordner erstellen>. Rufen Sie den Ordner Skripts auf.
Doppelklicken Sie auf den gerade erstellten Ordner, um ihn zu öffnen.
Klicken Sie mit der rechten Maustaste in den Ordner, und klicken Sie dann aufC#-Skripterstellen>. 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;Sie müssen nun 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 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 der Hauptkamera hinzufügt und die Label-Erstellungsmethode 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, die das Label-Objekt erstellt, 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 Methoden DetectFacesFromImage() und GetImageAsByteArray() hinzu. Ersterer fordert den Gesichtserkennungsdienst auf, ein mögliches Gesicht im übermittelten Bild zu erkennen, während letzteres erforderlich ist, um das erfasste Bild in ein Bytesarray 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 Gesichter zu identifizieren, die zuvor im übermittelten Bild erkannt wurden. Die Anforderung gibt eine ID der identifizierten Person zurück, aber nicht den Namen:
/// <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 Skript FaceAnalysis aus dem Ordner Skripts im Projektbereich auf das Objekt Hauptkamera im Bereich Hierarchie. 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 für die Kommunikation mit Ihrem Azure-Gesichtserkennungsdienst erforderlich sind, um das von Ihnen erfasste Bild zu analysieren, Gesichter darin zu identifizieren und zu bestimmen, ob es zu einer bekannten Person gehört. Wenn eine bekannte Person gefunden wird, zeigt diese Klasse ihren Namen als Benutzeroberflächentext 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 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 erforderlich sind, um die Klasse zu initialisieren und die 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 Tap-Geste ausführt:
/// <summary> /// Respond to Tap Input. /// </summary> private void TapHandler(TappedEventArgs obj) { tapsCount++; ExecuteImageCaptureAndAnalysis(); }Fügen Sie die ExecuteImageCaptureAndAnalysis()- Methode hinzu, die den Prozess der Bilderfassung 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 Fotoaufnahmeprozess 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 quer auf Ihre HoloLens laden.
Bevor Sie dies tun, stellen Sie Folgendes sicher:
- Alle in Kapitel 3 erwähnten Einstellungen sind richtig 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 sind Sie bereit, die Projektmappe zu erstellen. Nachdem die Lösung erstellt wurde, können Sie Ihre Anwendung bereitstellen.
So starten Sie den Buildvorgang:
Speichern Sie die aktuelle Szene, indem Sie auf Datei, Speichern klicken.
Wechseln Sie zu Datei, Buildeinstellungen, und klicken Sie auf Offene Szenen hinzufügen.
Aktivieren Sie unbedingt Unity C#-Projekte.
Drücken Sie Build. Anschließend startet Unity ein Explorer Fenster, in dem Sie einen Ordner erstellen und dann auswählen müssen, in dem die App erstellt werden soll. Erstellen Sie diesen Ordner jetzt innerhalb des Unity-Projekts, und nennen Sie ihn App. Drücken Sie dann, wenn der Ordner App ausgewählt ist, Ordner auswählen.
Unity beginnt mit der Erstellung Ihres Projekts im Ordner App.
Sobald Unity die Erstellung abgeschlossen hat (dies 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 (wie oben gezeigt, MR_FaceRecognition.sln).
Kapitel 9: Bereitstellen Ihrer Anwendung
So stellen Sie die Bereitstellung auf 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 dazu folgendermaßen vor:
- Öffnen Sie beim Tragen Ihrer HoloLens die Einstellungen.
- Wechseln Sie zu Netzwerk & Internet > Wi-Fi > Erweiterte Optionen
- Notieren Sie sich die IPv4-Adresse .
- Navigieren Sie als Nächstes zurück zu Einstellungen und dann zu Aktualisieren & Sicherheit > für Entwickler.
- Legen Sie den Entwicklermodus ein.
Navigieren Sie zu Ihrem neuen Unity-Build (dem Ordner App ), und öffnen Sie die Projektmappendatei mit Visual Studio.
Wählen Sie in der Projektmappenkonfiguration debuggen aus.
Wählen Sie auf der Lösungsplattform die Option x86, Remotecomputer aus.
Navigieren 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, bereit für den Start!
Hinweis
Legen Sie für die Bereitstellung in einem immersiven Headset die Lösungsplattform auf Lokaler Computer fest, und legen Sie die Konfiguration auf Debuggen fest, wobei x86 die Plattform ist. Stellen Sie dann die Bereitstellung auf dem lokalen Computer mithilfe des Menüs Erstellen bereit, und wählen Sie Projektmappe bereitstellen aus.
Kapitel 10: Verwenden der Anwendung
Starten Sie die App mit holoLens.
Sehen Sie sich die Person an, die Sie bei der Gesichtserkennungs-API registriert haben. Stellen Sie Folgendes sicher:
- Das Gesicht der Person ist nicht zu weit entfernt und deutlich sichtbar
- Die Umgebungsbeleuchtung ist nicht zu dunkel
Verwenden Sie die Tippen-Geste, um das Bild der Person zu erfassen.
Warten Sie, bis die App die Analyseanforderung sendet und eine Antwort erhält.
Wenn die Person erfolgreich erkannt wurde, wird der Name der Person als Benutzeroberflächentext angezeigt.
Sie können den Aufzeichnungsprozess alle paar Sekunden mit der Tippen-Geste wiederholen.
Ihre fertige Azure Face API-Anwendung
Herzlichen Glückwunsch! Sie haben eine Mixed Reality-App erstellt, die den Azure-Gesichtserkennungsdienst nutzt, um Gesichter in einem Bild zu erkennen und alle bekannten Gesichter zu identifizieren.
Zusatzübungen
Übung 1
Die Azure Face-API ist leistungsfähig genug, um bis zu 64 Gesichter in einem einzelnen Image zu erkennen. Erweitern Sie die Anwendung, sodass sie unter vielen anderen Personen zwei oder drei Gesichter erkennen kann.
Übung 2
Die Azure Face-API kann auch alle Arten von Attributinformationen zurückgeben. Integrieren Sie diese in die Anwendung. Dies könnte in Kombination mit der Emotion-API noch interessanter sein.