HoloLens (1e generatie) en Azure 304: Gezichtsherkenning
Notitie
De Mixed Reality Academy-zelfstudies zijn ontworpen met HoloLens (1e generatie) en Mixed Reality Immersive Headsets in gedachten. Daarom vinden we het belangrijk om deze zelfstudies te behouden voor ontwikkelaars die nog steeds op zoek zijn naar richtlijnen bij het ontwikkelen voor die apparaten. Deze zelfstudies worden niet bijgewerkt met de nieuwste toolsets of interacties die worden gebruikt voor HoloLens 2. Ze blijven behouden om door te gaan met het werken op de ondersteunde apparaten. Er is een nieuwe reeks zelfstudies die in de toekomst zullen worden gepost en die laten zien hoe u zich ontwikkelt voor HoloLens 2. Deze kennisgeving wordt bijgewerkt met een koppeling naar deze zelfstudies wanneer ze worden gepost.
In deze cursus leert u hoe u gezichtsherkenningsmogelijkheden toevoegt aan een mixed reality-toepassing, met behulp van Azure Cognitive Services, met de Microsoft Face-API.
Azure Face-API is een Microsoft-service, die ontwikkelaars de meest geavanceerde gezichtsalgoritmen biedt, allemaal in de cloud. De Face-API heeft twee hoofdfuncties: gezichtsdetectie met kenmerken en gezichtsherkenning. Hierdoor kunnen ontwikkelaars eenvoudig een set groepen instellen voor gezichten en vervolgens queryafbeeldingen naar de service verzenden om te bepalen aan wie een gezicht behoort. Ga naar de azure Face Recognition-pagina voor meer informatie.
Nadat u deze cursus hebt voltooid, hebt u een HoloLens-toepassing voor mixed reality, die het volgende kan doen:
- Gebruik een tikbeweging om de opname van een afbeelding te initiëren met behulp van de HoloLens-camera aan boord.
- Verzend de vastgelegde installatiekopieën naar de Azure Face API-service .
- De resultaten van het Face-API-algoritme ontvangen.
- Gebruik een eenvoudige gebruikersinterface om de naam van overeenkomende personen weer te geven.
Hiermee leert u hoe u de resultaten van de Face-API-service kunt ophalen in uw Mixed Reality-toepassing op basis van Unity.
In uw toepassing is het aan u om te bepalen hoe u de resultaten integreert met uw ontwerp. Deze cursus is ontworpen om u te leren hoe u een Azure-service integreert met uw Unity-project. Het is uw taak om de kennis die u uit deze cursus krijgt te gebruiken om uw mixed reality-toepassing te verbeteren.
Ondersteuning voor apparaten
| Cursus | HoloLens | Insluitende headsets |
|---|---|---|
| MR en Azure 304: Gezichtsherkenning | ✔️ | ✔️ |
Notitie
Hoewel deze cursus voornamelijk gericht is op HoloLens, kunt u ook toepassen wat u in deze cursus leert op Vr-headsets (Windows Mixed Reality immersive). Omdat insluitende headsets (VR) geen toegankelijke camera's hebben, hebt u een externe camera nodig die is aangesloten op uw pc. Terwijl u de cursus volgt, ziet u notities over eventuele wijzigingen die u mogelijk moet gebruiken om insluitende headsets (VR) te ondersteunen.
Vereisten
Notitie
Deze zelfstudie is ontworpen voor ontwikkelaars die basiservaring hebben met Unity en C#. Houd er ook rekening mee dat de vereisten en schriftelijke instructies in dit document staan voor wat is getest en geverifieerd op het moment van schrijven (mei 2018). U kunt de nieuwste software gebruiken, zoals vermeld in het artikel over de installatie van de hulpprogramma's , hoewel er niet van wordt uitgegaan dat de informatie in deze cursus perfect overeenkomt met wat u vindt in nieuwere software dan hieronder wordt vermeld.
Voor deze cursus raden we de volgende hardware en software aan:
- Een ontwikkel-pc, compatibel met Windows Mixed Reality voor insluitende headsetontwikkeling (VR)
- Windows 10 Fall Creators Update (of hoger) waarvoor de ontwikkelaarsmodus is ingeschakeld
- De nieuwste Windows 10 SDK
- Unity 2017.4
- Visual Studio 2017
- Een Windows Mixed Reality immersive (VR)-headset of Microsoft HoloLens waarvoor de ontwikkelaarsmodus is ingeschakeld
- Een camera die is aangesloten op uw pc (voor insluitende headsetontwikkeling)
- Internettoegang voor het instellen van Azure en het ophalen van de Face-API
Voordat u begint
- Om problemen met het bouwen van dit project te voorkomen, wordt u sterk aangeraden het project te maken dat in deze zelfstudie wordt genoemd in een hoofdmap of in een near-rootmap (lange mappaden kunnen problemen veroorzaken tijdens de build).
- Uw HoloLens instellen en testen. Als u ondersteuning nodig hebt voor het instellen van uw HoloLens, gaat u naar het installatieartikel van HoloLens.
- Het is een goed idee om kalibratie en sensorafstemming uit te voeren bij het ontwikkelen van een nieuwe HoloLens-app (soms kan het helpen om deze taken voor elke gebruiker uit te voeren).
Voor hulp bij kalibratie volgt u deze koppeling naar het HoloLens-kalibratieartikel.
Volg deze koppeling naar het artikel HoloLens Sensor Tuning voor hulp bij sensorafstemming.
Hoofdstuk 1: Azure Portal
Als u de Face-API-service in Azure wilt gebruiken, moet u een exemplaar van de service configureren dat beschikbaar moet worden gemaakt voor uw toepassing.
Meld u eerst aan bij Azure Portal.
Notitie
Als u nog geen Azure-account hebt, moet u er een maken. Als u deze zelfstudie volgt in een leslokaal- of labsituatie, vraagt u uw docent of een van de proctors voor hulp bij het instellen van uw nieuwe account.
Zodra u bent aangemeld, klikt u op Nieuw in de linkerbovenhoek en zoekt u naar de Face-API. Druk op Enter.
Notitie
Het woord Nieuw is mogelijk vervangen door Een resource maken in nieuwere portals.
De nieuwe pagina bevat een beschrijving van de Face-API-service . Selecteer linksonder in deze prompt de knop Maken om een koppeling met deze service te maken.
Zodra u op Maken hebt geklikt:
Voeg de gewenste naam in voor dit service-exemplaar.
Selecteer een abonnement.
Selecteer de prijscategorie die voor u geschikt is. Als dit de eerste keer is dat u een Face API-service maakt, moet er een gratis laag (met de naam F0) voor u beschikbaar zijn.
Kies een resourcegroep of maak een nieuwe. Een resourcegroep biedt een manier om de toegang te bewaken, te beheren, facturering in te richten en te beheren voor een verzameling Azure-assets. Het wordt aanbevolen om alle Azure-services die zijn gekoppeld aan één project (zoals deze labs) onder een gemeenschappelijke resourcegroep te houden.
Als u meer wilt weten over Azure-resourcegroepen, gaat u naar het artikel over de resourcegroep.
Voor de UWP-app, Person Maker, die u later gebruikt, is het gebruik van VS - west vereist voor locatie.
U moet ook bevestigen dat u de voorwaarden hebt begrepen die op deze Service zijn toegepast.
Selecteer Maken.*
Nadat u op Maken hebt geklikt, moet u wachten totdat de service is gemaakt. Dit kan een minuut duren.
Er wordt een melding weergegeven in de portal zodra het service-exemplaar is gemaakt.
Klik op de meldingen om uw nieuwe service-exemplaar te verkennen.
Wanneer u klaar bent, klikt u in de melding op De knop Naar de resource gaan om uw nieuwe service-exemplaar te verkennen.
In deze zelfstudie moet uw toepassing uw service aanroepen, wat wordt gedaan met behulp van de abonnementssleutel van uw service. Vanaf de pagina Snel starten van uw Face-API-service is het eerste punt nummer 1 om uw sleutels te pakken.
Selecteer op de pagina Service de blauwe hyperlink Sleutels (indien op de pagina Snel starten) of de koppeling Sleutels in het navigatiemenu van de services (links, aangeduid met het pictogram Sleutel), om uw sleutels weer te geven.
Notitie
Noteer een van de sleutels en beveilig deze, want u hebt deze later nodig.
Hoofdstuk 2: De UWP-toepassing Person Maker gebruiken
Zorg ervoor dat u de vooraf gemaakte UWP-toepassing met de naam Person Maker downloadt. Deze app is niet het eindproduct voor deze cursus, alleen een hulpprogramma waarmee u uw Azure-vermeldingen kunt maken, waarvan het latere project afhankelijk is.
Met Person Maker kunt u Azure-vermeldingen maken die zijn gekoppeld aan personen en groepen personen. De toepassing plaatst alle benodigde informatie in een indeling die later kan worden gebruikt door de FaceAPI om de gezichten te herkennen van personen die u hebt toegevoegd.
[BELANGRIJK] Person Maker maakt gebruik van een eenvoudige beperking om ervoor te zorgen dat u het aantal serviceoproepen per minuut voor de gratis abonnementslaag niet overschrijdt. De groene tekst bovenaan verandert in rood en wordt bijgewerkt als 'ACTIEF' wanneer er beperking plaatsvindt; Als dit het geval is, wacht u gewoon op de toepassing (het wacht totdat de toepassing vervolgens verder kan gaan met het openen van de face-service, wordt bijgewerkt als 'IN-ACTIVE' wanneer u deze opnieuw kunt gebruiken).
Deze toepassing maakt gebruik van de Microsoft.ProjectOxford.Face-bibliotheken , waarmee u volledig gebruik kunt maken van de Face-API. Deze bibliotheek is gratis beschikbaar als NuGet-pakket. Voor meer informatie hierover en vergelijkbare API's raadpleegt u het API-referentieartikel.
Notitie
Dit zijn alleen de vereiste stappen, instructies voor het uitvoeren van deze dingen vindt u verderop in het document. Met de Person Maker-app kunt u het volgende doen:
Maak een personengroep, een groep die bestaat uit verschillende personen die u eraan wilt koppelen. Met uw Azure-account kunt u meerdere personengroepen hosten.
Maak een persoon, die lid is van een personengroep. Aan elke persoon zijn een aantal Gezichtsafbeeldingen gekoppeld.
Wijs gezichtsafbeeldingen toe aan een persoon, zodat uw Azure Face API-service een persoon kan herkennen door het bijbehorende gezicht.
Uw Azure Face API-service trainen.
Als u deze app wilt trainen om personen te herkennen, hebt u tien (10) close-upfoto's nodig van elke persoon die u wilt toevoegen aan uw personengroep. De Windows 10 Cam-app kan u helpen om deze te nemen. U moet ervoor zorgen dat elke foto duidelijk is (vermijd vervaging, verdoezeling of te ver van het onderwerp), de foto in jpg- of PNG-bestandsindeling hebt, waarbij de bestandsgrootte van de afbeelding niet groter is dan 4 MB en niet minder dan 1 kB.
Notitie
Als u deze zelfstudie volgt, gebruikt u niet uw eigen gezicht voor training, net zoals wanneer u de HoloLens aanzet, kunt u niet naar uzelf kijken. Gebruik het gezicht van een collega of collega-student.
Person Maker uitvoeren:
Open de map PersonMaker en dubbelklik op de PersonMaker-oplossing om deze te openen met Visual Studio.
Zodra de PersonMaker-oplossing is geopend, controleert u of:
De oplossingsconfiguratie is ingesteld op Foutopsporing.
Het Solution Platform is ingesteld op x86
Het doelplatform is lokale computer.
Mogelijk moet u NuGet-pakketten herstellen (klik met de rechtermuisknop op de oplossing en selecteer NuGet-pakketten herstellen).
Klik op Lokale computer en de toepassing wordt gestart. Houd er rekening mee dat op kleinere schermen alle inhoud mogelijk niet zichtbaar is, maar u kunt verder omlaag schuiven om deze weer te geven.
Voeg uw Azure Authentication-sleutel in, die u moet hebben, vanuit uw Face API-service in Azure.
Invoegen:
- De id die u wilt toewijzen aan de personengroep. De id moet kleine letters bevatten, zonder spaties. Noteer deze id, want deze is later in uw Unity-project vereist.
- De naam die u wilt toewijzen aan de persoonsgroep (kan spaties bevatten).
Druk op de knop Persoonsgroep maken. Er wordt een bevestigingsbericht weergegeven onder de knop.
Notitie
Als u de fout 'Toegang geweigerd' hebt, controleert u de locatie die u hebt ingesteld voor uw Azure-service. Zoals hierboven vermeld, is deze app ontworpen voor 'VS - west'.
Belangrijk
U ziet dat u ook op de knop Een bekende groep ophalen kunt klikken: dit is bedoeld als u al een personengroep hebt gemaakt en dat wilt gebruiken in plaats van een nieuwe te maken. Houd er rekening mee dat als u op Een persoonsgroep maken met een bekende groep klikt, ook een groep wordt opgehaald.
Voeg de naam in van de persoon die u wilt maken.
Klik op de knop Persoon maken.
Er wordt een bevestigingsbericht weergegeven onder de knop.
Als u een persoon wilt verwijderen die u eerder hebt gemaakt, kunt u de naam naar het tekstvak schrijven en op Delete Person drukken
Zorg ervoor dat u de locatie weet van tien (10) foto's van de persoon die u aan uw groep wilt toevoegen.
Druk op Map maken en openen om Windows Verkenner te openen naar de map die aan de persoon is gekoppeld. Voeg de tien (10) afbeeldingen toe aan de map. Deze moeten een JPG- of PNG-bestandsindeling hebben.
Klik op Verzenden naar Azure. In een teller ziet u de status van de inzending, gevolgd door een bericht wanneer het is voltooid.
Zodra de teller is voltooid en er een bevestigingsbericht is weergegeven, klikt u op Trainen om uw service te trainen.
Zodra het proces is voltooid, bent u klaar om over te stappen naar Unity.
Hoofdstuk 3 - Het Unity-project instellen
Hier volgt een typische opzet voor het ontwikkelen met mixed reality en is als zodanig een goede sjabloon voor andere projecten.
Open Unity en klik op Nieuw.
U moet nu een Unity-projectnaam opgeven. Voeg MR_FaceRecognition in. Zorg ervoor dat het projecttype is ingesteld op 3D. Stel de locatie in op een locatie die geschikt is voor u (vergeet niet, dichter bij hoofdmappen is beter). Klik vervolgens op Project maken.
Als Unity is geopend, is het de moeite waard om te controleren of de standaardscripteditor is ingesteld op Visual Studio. Ga naar Voorkeuren bewerken > en navigeer vervolgens vanuit het nieuwe venster naar Externe hulpprogramma's. Wijzig de externe scripteditor in Visual Studio 2017. Sluit het venster Voorkeuren .
Ga vervolgens naar > Instellingen voor bestandsbuild en schakel het platform over naar Universeel Windows-platform door op de knop Platform wisselen te klikken.
Ga naar Instellingen voor bestandsbuild > en zorg ervoor dat:
Doelapparaat is ingesteld op HoloLens
Voor de insluitende headsets stelt u Doelapparaat in op Elk apparaat.
Buildtype is ingesteld op D3D
SDK is ingesteld op Laatst geïnstalleerd
Visual Studio-versie is ingesteld op Meest recent geïnstalleerd
Bouwen en uitvoeren is ingesteld op lokale computer
Sla de scène op en voeg deze toe aan de build.
Doe dit door Open Scènes toevoegen te selecteren. Er wordt een venster voor opslaan weergegeven.
Selecteer de knop Nieuwe map om een nieuwe map te maken, geef deze de naam Scènes.
Open de zojuist gemaakte map Scènes en typ vervolgens in het tekstvak Bestandsnaam, Typ FaceRecScene en druk op Opslaan.
De overige instellingen, in Build-instellingen, moeten voorlopig standaard blijven staan.
Klik in het venster Build-instellingen op de knop Spelerinstellingen . Hiermee opent u het gerelateerde deelvenster in de ruimte waar de Inspector zich bevindt.
In dit deelvenster moeten enkele instellingen worden geverifieerd:
Op het tabblad Overige instellingen :
Scripting Runtime-versie moet experimenteel zijn (.NET 4.6 Equivalent). Als u dit wijzigt, moet u de editor opnieuw starten.
Back-end voor scripts moet .NET zijn
API-compatibiliteitsniveau moet .NET 4.6 zijn
Schakel op het tabblad Publicatie-instellingen onder Mogelijkheden het volgende in:
InternetClient
Webcam
Schakel verderop in het deelvenster in XR-instellingen (hieronder Publicatie-instellingen) het selectievakje Virtual Reality Ondersteund in, zorg ervoor dat de Windows Mixed Reality SDK is toegevoegd.
In Build Settings wordt Unity C# Projects niet meer grijs weergegeven. Schakel het selectievakje naast dit selectievakje in.
Sluit het venster Build Settings.
Sla uw scène en project op (FILE > SAVE SCENE/ FILE > SAVE PROJECT).
Hoofdstuk 4 - Hoofdcamera instellen
Belangrijk
Als u het Unity Set up-onderdeel van deze cursus wilt overslaan en direct in code wilt doorgaan, kunt u deze .unitypackage downloaden en importeren in uw project als een aangepast pakket. Houd er rekening mee dat dit pakket ook de import van de Newtonsoft DLL omvat, die in hoofdstuk 5 wordt behandeld. Met deze geïmporteerde gegevens kunt u doorgaan vanaf hoofdstuk 6.
Selecteer in het deelvenster Hiërarchie de hoofdcamera.
Zodra deze optie is geselecteerd, kunt u alle onderdelen van de hoofdcamera in het inspectorpaneel zien.
Het cameraobject moet de naam Hoofdcamera hebben (let op de spelling!)
De hoofdcamera-tag moet worden ingesteld op MainCamera (let op de spelling!)
Zorg ervoor dat de positie van de transformatie is ingesteld op 0, 0, 0
Duidelijke vlaggen instellen op effen kleur
Stel de achtergrondkleur van het cameraonderdeel in op Zwart, Alpha 0 (Hex Code: #0000000000)
Hoofdstuk 5 – De Newtonsoft.Json-bibliotheek importeren
Belangrijk
Als u het .unitypackage in het laatste hoofdstuk hebt geïmporteerd, kunt u dit hoofdstuk overslaan.
Om u te helpen bij het deserialiseren en serialiseren van objecten die zijn ontvangen en verzonden naar de Bot Service, moet u de Newtonsoft.Json-bibliotheek downloaden. U vindt een compatibele versie die al is georganiseerd met de juiste Unity-mapstructuur in dit Unity-pakketbestand.
De bibliotheek importeren:
Download het Unity-pakket.
Klik op Assets, Import Package, Custom Package.
Zoek naar het Unity-pakket dat u hebt gedownload en klik op Openen.
Zorg ervoor dat alle onderdelen van het pakket zijn aangevinkt en klik op Importeren.
Hoofdstuk 6 - De klasse FaceAnalysis maken
Het doel van de FaceAnalysis-klasse is het hosten van de methoden die nodig zijn om te communiceren met uw Azure Face Recognition Service.
- Nadat de service een opnameafbeelding is verzonden, wordt deze geanalyseerd en geïdentificeerd binnen de gezichten en wordt bepaald of deze tot een bekende persoon behoren.
- Als een bekende persoon wordt gevonden, wordt in deze klasse de naam weergegeven als UI-tekst in de scène.
De klasse FaceAnalysis maken:
Klik met de rechtermuisknop in de map Activa in het deelvenster Project en klik vervolgens op Map maken>. Roep de mapscripts aan.
Dubbelklik op de zojuist gemaakte map om deze te openen.
Klik met de rechtermuisknop in de map en klik vervolgens op C#-script maken>. Roep het script FaceAnalysis aan.
Dubbelklik op het nieuwe FaceAnalysis-script om het te openen met Visual Studio 2017.
Voer de volgende naamruimten in boven de klasse FaceAnalysis :
using Newtonsoft.Json; using System.Collections; using System.Collections.Generic; using System.IO; using System.Text; using UnityEngine; using UnityEngine.Networking;U moet nu alle objecten toevoegen die worden gebruikt voor deserialisatie. Deze objecten moeten buiten het FaceAnalysis-script worden toegevoegd (onder de onderste accolade).
/// <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; } }De methoden Start() en Update() worden niet gebruikt, dus verwijder ze nu.
Voeg in de klasse FaceAnalysis de volgende variabelen toe:
/// <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 -";Notitie
Vervang de sleutel en de personGroupId door uw servicesleutel en de id van de groep die u eerder hebt gemaakt.
Voeg de Awake() -methode toe, die de klasse initialiseert, waarbij de klasse ImageCapture wordt toegevoegd aan de Main Camera en de methode Label maken wordt aangeroepen:
/// <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(); }Voeg de methode CreateLabel() toe, waarmee het labelobject wordt gemaakt om het analyseresultaat weer te geven:
/// <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 = "."; }Voeg de methode DetectFacesFromImage() en GetImageAsByteArray() toe. De eerste aanvraagt de Face Recognition Service om elk mogelijk gezicht in de ingediende afbeelding te detecteren, terwijl de laatste nodig is om de vastgelegde afbeelding te converteren naar een bytesmatrix:
/// <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); }Voeg de methode IdentifyFaces() toe, die de Face Recognition-service aanvraagt om een bekend gezicht te identificeren dat eerder in de ingediende afbeelding is gedetecteerd. De aanvraag retourneert een id van de geïdentificeerde persoon, maar niet de naam:
/// <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); } } }Voeg de methode GetPerson() toe. Door de persoons-id op te geven, vraagt deze methode de Face Recognition Service om de naam van de geïdentificeerde persoon te retourneren:
/// <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; } }Vergeet niet om de wijzigingen op te slaan voordat u teruggaat naar de Unity Editor.
Sleep in de Unity Editor het FaceAnalysis-script van de map Scripts in het deelvenster Project naar het object Main Camera in het deelvenster Hierarchy. Het nieuwe scriptonderdeel wordt zo toegevoegd aan de hoofdcamera.
Hoofdstuk 7 - De klasse ImageCapture maken
Het doel van de Klasse ImageCapture is het hosten van de methoden die nodig zijn om te communiceren met uw Azure Face Recognition Service om de afbeelding te analyseren die u wilt vastleggen, gezichten erin te identificeren en te bepalen of deze deel uitmaakt van een bekende persoon. Als een bekende persoon wordt gevonden, wordt in deze klasse de naam weergegeven als UI-tekst in de scène.
De klasse ImageCapture maken:
Klik met de rechtermuisknop in de map Scripts die u eerder hebt gemaakt en klik vervolgens op Maken, C#-script. Roep het script ImageCapture aan.
Dubbelklik op het nieuwe ImageCapture-script om het te openen met Visual Studio 2017.
Voer de volgende naamruimten in boven de klasse ImageCapture:
using System.IO; using System.Linq; using UnityEngine; using UnityEngine.XR.WSA.Input; using UnityEngine.XR.WSA.WebCam;Voeg in de klasse ImageCapture de volgende variabelen toe:
/// <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;Voeg de methoden Awake() en Start() toe die nodig zijn om de klasse te initialiseren en de HoloLens toe te staan de bewegingen van de gebruiker vast te leggen:
/// <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(); }Voeg de TapHandler() toe die wordt aangeroepen wanneer de gebruiker een tikbeweging uitvoert:
/// <summary> /// Respond to Tap Input. /// </summary> private void TapHandler(TappedEventArgs obj) { tapsCount++; ExecuteImageCaptureAndAnalysis(); }Voeg de methode ExecuteImageCaptureAndAnalysis() toe, waarmee het proces van het vastleggen van afbeeldingen wordt gestart:
/// <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); }); }); }Voeg de handlers toe die worden aangeroepen wanneer het fotoopnameproces is voltooid:
/// <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()); }Vergeet niet om de wijzigingen op te slaan voordat u teruggaat naar de Unity Editor.
Hoofdstuk 8 - De oplossing bouwen
Als u een grondige test van uw toepassing wilt uitvoeren, moet u deze sideloaden op uw HoloLens.
Voordat u dit doet, moet u ervoor zorgen dat:
- Alle instellingen die in hoofdstuk 3 worden genoemd, zijn correct ingesteld.
- Het script FaceAnalysis is gekoppeld aan het hoofdcameraobject.
- Zowel de verificatiesleutel als de groeps-id zijn ingesteld in het FaceAnalysis-script.
Een punt dat u klaar bent om de oplossing te bouwen. Zodra de oplossing is gebouwd, bent u klaar om uw toepassing te implementeren.
Ga als volgt te werk om het buildproces te starten:
Sla de huidige scène op door te klikken op Bestand, Opslaan.
Ga naar Bestand, Build Settings en klik op Open Scenes toevoegen.
Zorg ervoor dat u Unity C#-projecten aanvinkt.
Druk op Build. Als u dit doet, start Unity een Bestandenverkenner-venster waarin u een map moet maken en vervolgens een map selecteert waarin u de app wilt bouwen. Maak die map nu in het Unity-project en noem deze app. Druk vervolgens op Map selecteren terwijl de app-map is geselecteerd.
Unity begint met het bouwen van uw project, naar de app-map.
Zodra Unity klaar is met bouwen (het kan enige tijd duren), wordt er een Bestandenverkenner venster geopend op de locatie van uw build.
Open de map App en open vervolgens de nieuwe projectoplossing (zoals hierboven weergegeven, MR_FaceRecognition.sln).
Hoofdstuk 9: Uw toepassing implementeren
Implementeren op HoloLens:
U hebt het IP-adres van uw HoloLens nodig (voor Extern implementeren) en om ervoor te zorgen dat uw HoloLens zich in de ontwikkelaarsmodus bevindt. Dit doet u als volgt:
- Open de instellingen terwijl u uw HoloLens draagt.
- Ga naar Netwerk en Internet > Wi-Fi > Geavanceerde opties
- Noteer het IPv4-adres .
- Ga vervolgens terug naar Instellingen en ga vervolgens naar Update & Security > for Developers
- Stel de ontwikkelaarsmodus in.
Navigeer naar uw nieuwe Unity-build (de app-map ) en open het oplossingsbestand met Visual Studio.
Selecteer foutopsporing in de oplossingsconfiguratie.
Selecteer x86, Remote Machine in het Solution Platform.
Ga naar het menu Build en klik op Oplossing implementeren om de toepassing te sideloaden naar uw HoloLens.
Uw app moet nu worden weergegeven in de lijst met geïnstalleerde apps op uw HoloLens, klaar om te worden gestart.
Notitie
Als u wilt implementeren op een insluitende headset, stelt u het Solution Platform in op de lokale computer en stelt u de configuratie in op Foutopsporing, met x86 als platform. Implementeer vervolgens op de lokale computer met behulp van het menu Build en selecteer Oplossing implementeren.
Hoofdstuk 10 - De toepassing gebruiken
Start de app met de HoloLens.
Bekijk de persoon die u hebt geregistreerd bij de Face-API. Zorg voor het volgende:
- Het gezicht van de persoon is niet te ver en duidelijk zichtbaar
- De omgevingsverlichting is niet te donker
Gebruik de tikbeweging om de foto van de persoon vast te leggen.
Wacht totdat de app de analyseaanvraag verzendt en een antwoord ontvangt.
Als de persoon is herkend, wordt de naam van de persoon weergegeven als ui-tekst.
U kunt het opnameproces herhalen met behulp van de tikbeweging om de paar seconden.
Uw voltooide Azure Face API-toepassing
Gefeliciteerd, u hebt een mixed reality-app gebouwd die gebruikmaakt van de Azure Face Recognition-service om gezichten in een afbeelding te detecteren en bekende gezichten te identificeren.
Bonusoefeningen
Oefening 1
De Azure Face-API is krachtig genoeg om maximaal 64 gezichten in één afbeelding te detecteren. Breid de toepassing uit, zodat deze twee of drie gezichten kan herkennen, onder vele andere personen.
Oefening 2
De Azure Face-API kan ook allerlei soorten kenmerkgegevens bieden. Integreer dit in de toepassing. Dit kan nog interessanter zijn, in combinatie met de Emotion-API.