HoloLens (första generationen) och Azure 304: Ansiktsigenkänning
Kommentar
Självstudierna för Mixed Reality Academy har utformats med HoloLens (första generationen) och Mixed Reality Immersive Headsets i åtanke. Därför anser vi att det är viktigt att låta de här självstudierna vara kvar för utvecklare som fortfarande letar efter vägledning för att utveckla för dessa enheter. De här självstudierna uppdateras inte med de senaste verktygsuppsättningarna eller interaktionerna som används för HoloLens 2. De underhålls för att fortsätta arbeta med de enheter som stöds. Det kommer att finnas en ny serie självstudier som kommer att publiceras i framtiden som visar hur du utvecklar för HoloLens 2. Det här meddelandet uppdateras med en länk till de självstudierna när de publiceras.
I den här kursen får du lära dig hur du lägger till funktioner för ansiktsigenkänning i ett program för mixad verklighet med hjälp av Azure Cognitive Services med Microsofts ansikts-API.
Azure Face API är en Microsoft-tjänst som ger utvecklare de mest avancerade ansiktsalgoritmerna, allt i molnet. Ansikts-API:et har två huvudfunktioner: ansiktsidentifiering med attribut och ansiktsigenkänning. På så sätt kan utvecklare helt enkelt ange en uppsättning grupper för ansikten och sedan skicka frågebilder till tjänsten senare för att avgöra vem ett ansikte tillhör. Mer information finns på sidan ansiktsigenkänning i Azure.
När du har slutfört den här kursen har du ett HoloLens-program för mixad verklighet som kan göra följande:
- Använd en tryckgest för att initiera avbildningen av en bild med hjälp av den inbyggda HoloLens-kameran.
- Skicka den insamlade avbildningen till Azure Face API-tjänsten .
- Ta emot resultatet av ansikts-API-algoritmen.
- Använd ett enkelt användargränssnitt för att visa namnet på matchade personer.
På så sätt får du lära dig hur du hämtar resultaten från Ansikts-API-tjänsten till ditt Unity-baserade program för mixad verklighet.
I ditt program är det upp till dig hur du ska integrera resultaten med din design. Den här kursen är utformad för att lära dig hur du integrerar en Azure-tjänst med ditt Unity-projekt. Det är ditt jobb att använda den kunskap du får från den här kursen för att förbättra din mixed reality-app.
Stöd för enheter
| Kurs | HoloLens | Uppslukande headset |
|---|---|---|
| MR och Azure 304: Ansiktsigenkänning | ✔️ | ✔️ |
Kommentar
Den här kursen fokuserar främst på HoloLens, men du kan även tillämpa det du lär dig i den här kursen på Windows Mixed Reality-headset (VR). Eftersom integrerande (VR) headset inte har tillgängliga kameror behöver du en extern kamera ansluten till datorn. När du följer kursen visas anteckningar om eventuella ändringar som du kan behöva använda för att stödja uppslukande (VR) headset.
Förutsättningar
Kommentar
Den här självstudien är utformad för utvecklare som har grundläggande erfarenhet av Unity och C#. Tänk också på att förutsättningarna och de skriftliga instruktionerna i det här dokumentet representerar det som har testats och verifierats i skrivande stund (maj 2018). Du är fri att använda den senaste programvaran, som anges i artikeln installera verktyg , men det bör inte antas att informationen i den här kursen perfekt matchar vad du hittar i nyare programvara än vad som anges nedan.
Vi rekommenderar följande maskinvara och programvara för den här kursen:
- En utvecklingsdator som är kompatibel med Windows Mixed Reality för avancerad (VR) headsetutveckling
- Windows 10 Fall Creators Update (eller senare) med utvecklarläge aktiverat
- Den senaste Windows 10 SDK
- Unity 2017.4
- Visual Studio 2017
- Ett Windows Mixed Reality-headset (VR) eller Microsoft HoloLens med utvecklarläge aktiverat
- En kamera som är ansluten till datorn (för avancerad headsetutveckling)
- Internetåtkomst för Azure-konfiguration och ansikts-API-hämtning
Innan du börjar
- För att undvika problem med att skapa det här projektet rekommenderar vi starkt att du skapar projektet som nämns i den här självstudien i en rotmapp eller nära rotmapp (långa mappsökvägar kan orsaka problem vid byggtid).
- Konfigurera och testa dina HoloLens. Om du behöver stöd för att konfigurera HoloLens ska du gå till installationsartikeln för HoloLens.
- Det är en bra idé att utföra kalibrering och sensorjustering när du börjar utveckla en ny HoloLens-app (ibland kan det hjälpa till att utföra dessa uppgifter för varje användare).
Om du behöver hjälp med kalibrering kan du följa den här länken till artikeln HoloLens-kalibrering.
Om du vill ha hjälp med sensorjustering följer du den här länken till artikeln HoloLens Sensor Tuning.
Kapitel 1 – Azure Portal
Om du vill använda ansikts-API-tjänsten i Azure måste du konfigurera en instans av tjänsten som ska göras tillgänglig för ditt program.
Logga först in på Azure-portalen.
Kommentar
Om du inte redan har ett Azure-konto måste du skapa ett. Om du följer den här självstudien i en klassrums- eller labbsituation ber du din instruktör eller någon av rektorerna om hjälp med att konfigurera ditt nya konto.
När du är inloggad klickar du på Nytt i det övre vänstra hörnet och söker efter Ansikts-API, trycker på Retur.
Kommentar
Ordet Nytt kan ha ersatts med Skapa en resurs i nyare portaler.
Den nya sidan innehåller en beskrivning av ansikts-API-tjänsten . Längst ned till vänster i den här prompten väljer du knappen Skapa för att skapa en association med den här tjänsten.
När du har klickat på Skapa:
Infoga önskat namn för den här tjänstinstansen.
Välj en prenumeration.
Välj den prisnivå som är lämplig för dig, om det är första gången du skapar en ansikts-API-tjänst bör en kostnadsfri nivå (med namnet F0) vara tillgänglig för dig.
Välj en resursgrupp eller skapa en ny. En resursgrupp är ett sätt att övervaka, kontrollera åtkomst, etablera och hantera fakturering för en samling Azure-tillgångar. Vi rekommenderar att du behåller alla Azure-tjänster som är associerade med ett enda projekt (t.ex. dessa labb) under en gemensam resursgrupp).
Om du vill läsa mer om Azure-resursgrupper kan du gå till resursgruppens artikel.
UWP-appen, Person Maker, som du använder senare, kräver användning av "USA, västra" för plats.
Du måste också bekräfta att du har förstått de villkor som gäller för den här tjänsten.
Välj Skapa.*
När du har klickat på Skapa* måste du vänta tills tjänsten har skapats, det kan ta en minut.
Ett meddelande visas i portalen när tjänstinstansen har skapats.
Klicka på meddelandena för att utforska din nya tjänstinstans.
När du är klar klickar du på knappen Gå till resurs i meddelandet för att utforska din nya tjänstinstans.
I den här självstudien måste ditt program göra anrop till din tjänst, vilket görs med hjälp av tjänstens prenumerationsnyckel. På sidan Snabbstart för din ansikts-API-tjänst är den första punkten nummer 1 för att hämta dina nycklar.
På sidan Tjänst väljer du antingen den blå hyperlänken Nycklar (om på sidan Snabbstart) eller länken Nycklar i tjänstnavigeringsmenyn (till vänster, som anges av nyckelikonen) för att visa dina nycklar.
Kommentar
Anteckna någon av nycklarna och skydda den, eftersom du behöver den senare.
Kapitel 2 – Använda UWP-programmet "Person Maker"
Se till att ladda ned det fördefinierade UWP-programmet med namnet Person Maker. Den här appen är inte slutprodukten för den här kursen, bara ett verktyg som hjälper dig att skapa dina Azure-poster, som det senare projektet kommer att förlita sig på.
Med Person Maker kan du skapa Azure-poster som är associerade med personer och grupper av personer. Programmet placerar all nödvändig information i ett format som sedan senare kan användas av FaceAPI för att identifiera ansikten för personer som du har lagt till.
[VIKTIGT] Person Maker använder vissa grundläggande begränsningar för att säkerställa att du inte överskrider antalet tjänstanrop per minut för den kostnadsfria prenumerationsnivån. Den gröna texten längst upp ändras till röd och uppdateras som "ACTIVE" när begränsningen sker. Om så är fallet väntar du bara på programmet (det väntar tills det kan fortsätta att komma åt ansiktstjänsten och uppdateras som "IN-ACTIVE" när du kan använda det igen).
Det här programmet använder Microsoft.ProjectOxford.Face-biblioteken , vilket gör att du kan använda ansikts-API:et fullt ut. Det här biblioteket är tillgängligt kostnadsfritt som ett NuGet-paket. Mer information om detta och liknande api:er finns i API-referensartikeln.
Kommentar
Det här är bara de steg som krävs. Instruktioner för hur du gör dessa saker finns längre ned i dokumentet. Med appen Person Maker kan du:
Skapa en persongrupp, som är en grupp som består av flera personer som du vill associera med den. Med ditt Azure-konto kan du vara värd för flera persongrupper.
Skapa en person, som är medlem i en persongrupp. Varje person har ett antal ansiktsbilder kopplade till sig.
Tilldela ansiktsbilder till en person så att din Azure Face API-tjänst kan identifiera en person med motsvarande ansikte.
Träna din Azure Face API-tjänst.
Tänk på att för att träna den här appen att känna igen personer behöver du tio (10) närbilder av varje person som du vill lägga till i din persongrupp. Windows 10 Cam App kan hjälpa dig att ta dessa. Du måste se till att varje foto är tydligt (undvik att sudda ut, dölja eller vara för långt från motivet), ha fotot i jpg- eller png-filformat, där bildfilens storlek inte är större än 4 MB och inte mindre än 1 KB.
Kommentar
Om du följer den här självstudien ska du inte använda ditt eget ansikte för träning, som när du sätter på HoloLens kan du inte titta på dig själv. Använd en kollegas eller studentkollegas ansikte.
Personskapare som körs:
Öppna mappen PersonMaker och dubbelklicka på PersonMaker-lösningen för att öppna den med Visual Studio.
När PersonMaker-lösningen är öppen kontrollerar du att:
Lösningskonfigurationen är inställd på Felsök.
Lösningsplattformen är inställd på x86
Målplattformen är lokal dator.
Du kan också behöva återställa NuGet-paket (högerklicka på lösningen och välj Återställ NuGet-paket).
Klicka på Lokal dator så startas programmet. Tänk på att på mindre skärmar kanske allt innehåll inte är synligt, men du kan rulla längre ned för att visa det.
Infoga din Azure-autentiseringsnyckel, som du bör ha, från din Ansikts-API-tjänst i Azure.
Infoga:
- Det ID som du vill tilldela till persongruppen. ID:t måste vara gemener utan blanksteg. Anteckna det här ID:t eftersom det kommer att krävas senare i ditt Unity-projekt.
- Namnet som du vill tilldela till persongruppen (kan ha blanksteg).
Tryck på knappen Skapa persongrupp . Ett bekräftelsemeddelande bör visas under knappen.
Kommentar
Om du har ett felmeddelande om nekad åtkomst kontrollerar du den plats som du har angett för Din Azure-tjänst. Som nämnts ovan är den här appen utformad för "USA, västra".
Viktigt!
Du kommer att märka att du också kan klicka på knappen Hämta en känd grupp : detta gäller om du redan har skapat en persongrupp och vill använda den i stället för att skapa en ny. Tänk på att om du klickar på Skapa en persongrupp med en känd grupp hämtar detta även en grupp.
Infoga namnet på den person som du vill skapa.
Klicka på knappen Skapa person .
Ett bekräftelsemeddelande bör visas under knappen.
Om du vill ta bort en person som du har skapat tidigare kan du skriva namnet i textrutan och trycka på Ta bort person
Kontrollera att du känner till platsen för tio (10) foton av den person som du vill lägga till i din grupp.
Tryck på Skapa och öppna mapp för att öppna Utforskaren i mappen som är associerad med personen. Lägg till de tio (10) bilderna i mappen. Dessa måste vara av JPG - eller PNG-filformat .
Klicka på Skicka till Azure. En räknare visar tillståndet för sändningen, följt av ett meddelande när det har slutförts.
När räknaren är klar och ett bekräftelsemeddelande har visats klickar du på Träna för att träna din tjänst.
När processen har slutförts är du redo att gå vidare till Unity.
Kapitel 3 – Konfigurera Unity-projektet
Följande är en typisk konfiguration för utveckling med mixad verklighet och är därför en bra mall för andra projekt.
Öppna Unity och klicka på Nytt.
Nu måste du ange ett Unity-projektnamn. Infoga MR_FaceRecognition. Kontrollera att projekttypen är inställd på 3D. Ange platsen till någonstans som passar dig (kom ihåg att närmare rotkataloger är bättre). Klicka sedan på Skapa projekt.
När Unity är öppet är det värt att kontrollera att standardskriptredigeraren är inställd på Visual Studio. Gå till Redigera > inställningar och gå sedan till Externa verktyg från det nya fönstret. Ändra extern skriptredigerare till Visual Studio 2017. Stäng fönstret Inställningar .
Gå sedan till Inställningar för filbygge > och växla plattformen till Universal Windows Platform genom att klicka på knappen Växla plattform.
Gå till Inställningar för filbygge > och kontrollera att:
Målenheten är inställd på HoloLens
För de uppslukande headseten anger du Målenhet till Valfri enhet.
Byggtyp är inställd på D3D
SDK är inställt på Senaste installerat
Visual Studio-versionen är inställd på Senaste installerad
Build and Run är inställt på Lokal dator
Spara scenen och lägg till den i bygget.
Gör detta genom att välja Lägg till öppna scener. Ett spara-fönster visas.
Välj knappen Ny mapp för att skapa en ny mapp och ge den namnet Scener.
Öppna den nyligen skapade mappen Scener och skriv FaceRecScene i fältet Filnamn: text och tryck sedan på Spara.
De återstående inställningarna i Bygginställningar bör vara kvar som standard för tillfället.
I fönstret Bygginställningar klickar du på knappen Spelarinställningar. Då öppnas den relaterade panelen i det utrymme där inspektören finns.
I den här panelen måste några inställningar verifieras:
På fliken Andra inställningar :
Skriptkörningsversionen ska vara experimentell (.NET 4.6 Motsvarande). Om du ändrar detta utlöses ett behov av att starta om redigeraren.
Skriptserverdelen ska vara .NET
API-kompatibilitetsnivån ska vara .NET 4.6
På fliken Publiceringsinställningar går du till Funktioner och kontrollerar:
InternetClient
Webbkamera
Längre ned på panelen, i XR-inställningar (som finns under Publiceringsinställningar), markerar du Virtual Reality Supported (Virtual Reality Supported) och kontrollerar att Windows Mixed Reality SDK har lagts till.
I Bygginställningar är Unity C# Projects inte längre nedtonat. Markera kryssrutan bredvid detta.
Stäng fönstret Build Settings (Bygginställningar).
Spara scen och projekt (FILE > SAVE SCENE/FILE > SAVE PROJECT).
Kapitel 4 – Installation av huvudkamera
Viktigt!
Om du vill hoppa över Unity Set up-komponenten i den här kursen och fortsätta direkt till koden kan du ladda ned .unitypackage och importera den till projektet som ett anpassat paket. Tänk på att det här paketet även innehåller import av Newtonsoft DLL, som beskrivs i kapitel 5. Med detta importerat kan du fortsätta från kapitel 6.
I hierarkipanelen väljer du huvudkameran.
När du har valt kan du se alla komponenter i huvudkameran i kontrollpanelen.
Kameraobjektet måste ha namnet Main Camera (notera stavningen!)
Huvudkamerataggen måste vara inställd på MainCamera (observera stavningen!)
Kontrollera att transformeringspositionen är inställd på 0, 0, 0
Ange Clear Flags till Enfärgad
Ange bakgrundsfärgen för kamerakomponenten till Svart, Alfa 0 (Hexkod: #000000000)
Kapitel 5 – Importera Newtonsoft.Json-biblioteket
Viktigt!
Om du importerade ".unitypackage" i det senaste kapitlet kan du hoppa över det här kapitlet.
För att hjälpa dig att deserialisera och serialisera objekt som tagits emot och skickats till bottjänsten måste du ladda ned Newtonsoft.Json-biblioteket . Du hittar en kompatibel version som redan är organiserad med rätt Unity-mappstruktur i den här Unity-paketfilen.
Så här importerar du biblioteket:
Ladda ned Unity-paketet.
Klicka på Tillgångar, Importera paket, Anpassat paket.
Leta efter Unity-paketet som du har laddat ned och klicka på Öppna.
Kontrollera att alla komponenter i paketet är markerade och klicka på Importera.
Kapitel 6 – Skapa klassen FaceAnalysis
Syftet med klassen FaceAnalysis är att vara värd för de metoder som krävs för att kommunicera med din Azure Face Recognition Service.
- När tjänsten har skickat en avbildningsbild analyserar den och identifierar ansikten inom och avgör om någon tillhör en känd person.
- Om en känd person hittas visar den här klassen sitt namn som UI-text i scenen.
Så här skapar du klassen FaceAnalysis :
Högerklicka i mappen Tillgångar i projektpanelen och klicka sedan på Skapa>mapp. Anropa mappen Skript.
Dubbelklicka på mappen som nyss skapades för att öppna den.
Högerklicka i mappen och klicka sedan på Skapa>C#-skript. Anropa skriptet FaceAnalysis.
Dubbelklicka på det nya FaceAnalysis-skriptet för att öppna det med Visual Studio 2017.
Ange följande namnområden ovanför klassen FaceAnalysis :
using Newtonsoft.Json; using System.Collections; using System.Collections.Generic; using System.IO; using System.Text; using UnityEngine; using UnityEngine.Networking;Nu måste du lägga till alla objekt som används för deserialisering. Dessa objekt måste läggas till utanför FaceAnalysis-skriptet (under den nedre klammerparentesen).
/// <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; } }Metoderna Start() och Update() används inte, så ta bort dem nu.
Lägg till följande variabler i klassen FaceAnalysis :
/// <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 -";Kommentar
Ersätt nyckeln och personGroupId med din tjänstnyckel och ID:t för den grupp som du skapade tidigare.
Lägg till metoden Awake(), som initierar klassen, lägger till klassen ImageCapture i Main Camera och anropar metoden Skapa etikett:
/// <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(); }Lägg till metoden CreateLabel() som skapar etikettobjektet för att visa analysresultatet:
/// <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 = "."; }Lägg till metoden DetectFacesFromImage() och GetImageAsByteArray(). Den förstnämnda begär att ansiktsigenkänningstjänsten identifierar alla möjliga ansikten i den skickade bilden, medan den senare är nödvändig för att konvertera den insamlade bilden till en bytematris:
/// <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); }Lägg till metoden IdentifyFaces() som begär ansiktsigenkänningstjänsten för att identifiera alla kända ansikten som tidigare identifierats i den skickade bilden. Begäran returnerar ett ID för den identifierade personen men inte namnet:
/// <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); } } }Lägg till metoden GetPerson(). Genom att ange person-ID:t begär den här metoden sedan att ansiktsigenkänningstjänsten ska returnera namnet på den identifierade personen:
/// <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; } }Kom ihåg att spara ändringarna innan du går tillbaka till Unity-redigeraren.
Dra FaceAnalysis-skriptet från mappen Skript i projektpanelen till huvudkameraobjektet i hierarkipanelen i Unity-redigeraren. Den nya skriptkomponenten läggs till i huvudkameran.
Kapitel 7 – Skapa klassen ImageCapture
Syftet med klassen ImageCapture är att vara värd för de metoder som krävs för att kommunicera med din Azure Face Recognition Service för att analysera den bild som du kommer att avbilda, identifiera ansikten i den och avgöra om den tillhör en känd person. Om en känd person hittas visar den här klassen sitt namn som UI-text i scenen.
Så här skapar du klassen ImageCapture :
Högerklicka i mappen Skript som du skapade tidigare och klicka sedan på Skapa C #-skript. Anropa skriptet ImageCapture.
Dubbelklicka på det nya ImageCapture-skriptet för att öppna det med Visual Studio 2017.
Ange följande namnområden ovanför klassen ImageCapture:
using System.IO; using System.Linq; using UnityEngine; using UnityEngine.XR.WSA.Input; using UnityEngine.XR.WSA.WebCam;Lägg till följande variabler i klassen ImageCapture :
/// <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;Lägg till metoderna Awake() och Start() som krävs för att initiera klassen och låta HoloLens fånga användarens gester:
/// <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(); }Lägg till TapHandler() som anropas när användaren utför en Tryckgest:
/// <summary> /// Respond to Tap Input. /// </summary> private void TapHandler(TappedEventArgs obj) { tapsCount++; ExecuteImageCaptureAndAnalysis(); }Lägg till metoden ExecuteImageCaptureAndAnalysis(), som påbörjar processen med bildfångst:
/// <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); }); }); }Lägg till de hanterare som anropas när fotoinspelningsprocessen har slutförts:
/// <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()); }Kom ihåg att spara ändringarna innan du går tillbaka till Unity-redigeraren.
Kapitel 8 – Skapa lösningen
För att utföra ett grundligt test av ditt program måste du läsa in det separat på HoloLens.
Innan du gör det kontrollerar du att:
- Alla inställningar som anges i kapitel 3 är korrekt inställda.
- Skriptet FaceAnalysis är kopplat till huvudkameraobjektet.
- Både autentiseringsnyckeln och grupp-ID:t har angetts i FaceAnalysis-skriptet.
Nu är du redo att skapa lösningen. När lösningen har skapats är du redo att distribuera ditt program.
Så här påbörjar du byggprocessen:
Spara den aktuella scenen genom att klicka på Arkiv, Spara.
Gå till Fil, Skapa inställningar, klicka på Lägg till öppna scener.
Se till att kryssa i Unity C#-projekt.
Tryck på Skapa. När du gör det startar Unity ett Istraživač datoteka fönster där du behöver skapa och väljer sedan en mapp som appen ska byggas in i. Skapa mappen nu i Unity-projektet och kalla den App. Tryck sedan på Välj mapp med appmappen markerad.
Unity börjar skapa projektet, ut till mappen App.
När Unity har skapats (det kan ta lite tid) öppnas ett Istraživač datoteka fönster på platsen för bygget.
Öppna mappen App och öppna sedan den nya projektlösningen (se ovan MR_FaceRecognition.sln).
Kapitel 9 – Distribuera ditt program
Så här distribuerar du på HoloLens:
Du behöver IP-adressen för dina HoloLens (för fjärrdistribution) och för att säkerställa att HoloLens är i utvecklarläge. Så här gör du:
- Öppna inställningarna när du använder HoloLens.
- Gå till Avancerade alternativ för nätverks- och Internet-Wi-Fi > >
- Observera IPv4-adressen.
- Gå sedan tillbaka till Inställningar och sedan till Uppdatera och säkerhet > för utvecklare
- Ange utvecklarläge på.
Gå till din nya Unity-version (appmappen) och öppna lösningsfilen med Visual Studio.
I Lösningskonfiguration väljer du Felsök.
I Lösningsplattformen väljer du x86, Fjärrdator.
Gå till menyn Skapa och klicka på Distribuera lösning för att separat läsa in programmet till dina HoloLens.
Din app bör nu visas i listan över installerade appar på HoloLens, redo att startas!
Kommentar
Om du vill distribuera till ett uppslukande headset ställer du in Lösningsplattformen på Lokal dator och ställer in konfigurationen på Felsökning med x86 som plattform. Distribuera sedan till den lokala datorn med hjälp av menyn Skapa och välj Distribuera lösning.
Kapitel 10 – Använda programmet
Starta appen med HoloLens.
Titta på den person som du har registrerat med ansikts-API:et. Se till att:
- Personens ansikte är inte för avlägset och tydligt synligt
- Miljöbelysningen är inte för mörk
Använd tryckgesten för att avbilda personens bild.
Vänta tills appen skickar analysbegäran och får ett svar.
Om personen har identifierats visas personens namn som användargränssnittstext.
Du kan upprepa avbildningsprocessen med hjälp av tryckgesten med några sekunders mellanrum.
Ditt färdiga Azure Face API-program
Grattis, du har skapat en app för mixad verklighet som använder Tjänsten Ansiktsigenkänning i Azure för att identifiera ansikten i en bild och identifiera kända ansikten.
Bonusövningar
Övning 1
Azure Ansikts-API:et är tillräckligt kraftfullt för att identifiera upp till 64 ansikten i en enda bild. Utöka programmet så att det kan känna igen två eller tre ansikten, bland många andra personer.
Övning 2
Azure Face API kan också ge tillbaka alla typer av attributinformation. Integrera detta i programmet. Detta kan vara ännu mer intressant när det kombineras med Känslo-API:et.