HoloLens (1. generációs) és az Azure 304: Arcfelismerés


Megjegyzés

A Mixed Reality Academy oktatóanyagai HoloLens (1. generációs) és Mixed Reality Modern headsetekkel készültek. Ezért fontos, hogy ezeket az oktatóanyagokat a helyére helyezzük azoknak a fejlesztőknek, akik továbbra is útmutatást keresnek az eszközök fejlesztéséhez. Ezek az oktatóanyagok nem frissülnek a 2. HoloLens eszközökkel. A rendszer fenntartja őket, hogy továbbra is a támogatott eszközökön dolgoznak. A jövőben egy új oktatóanyag-sorozat lesz közzétéve, amely bemutatja, hogyan fejleszthet a 2. HoloLens való fejlesztéshez. Ez az értesítés frissülni fog az oktatóanyagokra mutató hivatkozással, amikor közzé lesznek téve.


a kurzus befejezésének eredménye

Ebben a kurzusban megtudhatja, hogyan adhat arcfelismerési képességeket egy vegyes valóságú alkalmazáshoz a microsoftos Face API Azure Cognitive Services használatával.

Az Azure Face API egy Microsoft-szolgáltatás, amely a legfejlettebb arc algoritmusokat biztosítja a fejlesztők számára, mindezt a felhőben. A Face API két fő funkcióval rendelkezik: attribútumokkal való arcfelismeréssel és arcfelismeréssel. Ez lehetővé teszi a fejlesztők számára, hogy egyszerűen csoportokat állítsanak be az arcok számára, majd később lekérdező képeket küldjenek a szolgáltatásnak, hogy megállapítsák, kihez tartozik egy arc. További információért látogasson el az Azure Face Recognition oldalára.

A kurzus befejezése után vegyes valósággal fog HoloLens alkalmazással, amely a következőket képes lesz végrehajtani:

  1. Egy koppintásos kézmozdulattal kezdeményezheti egy kép rögzítését a kamera HoloLens használatával.
  2. Küldje el a rögzített képet az Azure Face API szolgáltatásnak.
  3. A Face API algoritmus eredményeinek fogadása.
  4. Egy egyszerű Felhasználói felület az egyező személyek nevének megjelenítéséhez.

Ez bemutatja, hogyan lehet eredményeket behozni a Face API szolgáltatásból a Unity-alapú vegyes valóságon alapuló alkalmazásba.

Az alkalmazásban Ön kell, hogy hogyan integrálja az eredményeket a tervbe. Ennek a kurzusnak az a célja, hogy megtanítsa, hogyan integrálhat egy Azure-szolgáltatást a Unity-Project. Az Ön feladata, hogy az ebben a kurzusban megszerezhető ismereteket használja fel a vegyes valóságon áteső alkalmazás továbbfejleszt használása érdekében.

Eszköztámogatás

Tanfolyam HoloLens Modern headsetek
MR és Azure 304: Arcfelismerés ✔️ ✔️

Megjegyzés

Bár ez a kurzus elsősorban a HoloLens foglalkozik, az ebben a kurzusban tanultak használhatja a Windows Mixed Reality (VR-) headsetek kezeléséhez. Mivel a modern (VR-) headsetek nem érhetők el kamerákkal, a számítógéphez csatlakoztatott külső kamerára lesz szükség. Ahogy követi a tanfolyamot, jegyzeteket fog látni a modern (VR-) headsetek támogatásához esetlegesen szükséges módosításokról.

Előfeltételek

Megjegyzés

Ez az oktatóanyag olyan fejlesztők számára készült, akik alapszintű tapasztalattal rendelkeznek a Unity és a C# használatában. Vegye figyelembe azt is, hogy a jelen dokumentumban található előfeltételek és írásos utasítások a cikk írásakor tesztelt és ellenőrzött adatokat (2018. május) írják le. Használhatja a legújabb szoftvereket az eszközök telepítésével kapcsolatos cikkben felsoroltak szerint, de nem szabad feltételezni, hogy a kurzusban szereplő információk tökéletesen megegyeznek az újabb szoftverekben található információkkal, mint az alább felsoroltak.

Ehhez a kurzushoz a következő hardvereket és szoftvereket javasoljuk:

Előkészületek

  1. A projekt létrehozásakor felmerülő problémák elkerülése érdekében határozottan javasoljuk, hogy az oktatóanyagban említett projektet egy gyökér- vagy gyökérmappában hozza létre (a hosszú mappák elérési útjai problémákat okozhatnak a létrehozáskor).
  2. Állítsa be és tesztelje a HoloLens. Ha támogatásra van szüksége a HoloLens beállításához, mindenképpen látogasson el a HoloLens cikkre.
  3. Az új HoloLens alkalmazás fejlesztésekor (néha segíthet, ha ezeket a feladatokat minden felhasználónál el tudja végezni) egy kis behangolási és érzékelőhangolási műveletet.

Ha segítségre van szüksége a hibaelrehozásról, kövesse ezt a hivatkozást, amely a HoloLens cikkre hivatkozik.

Ha segítségre van szüksége az érzékelő hangolásával, kövesse ezt a hivatkozást, amely a HoloLens Sensor Tuning (Érzékelő hangolása) cikkben található.

1. fejezet – Az Azure Portal

A Face API szolgáltatás Azure-ban való használatához konfigurálnia kell a szolgáltatás egy példányát, hogy elérhető legyen az alkalmazás számára.

  1. Először jelentkezzen be az Azure Portalra.

    Megjegyzés

    Ha még nem rendelkezik Azure-fiókkal, létre kell hoznia egyet. Ha osztályterem- vagy laborhelyzetben követi ezt az oktatóanyagot, kérjen segítséget az oktatótól vagy az egyik vezetőtől az új fiók beállításában.

  2. Miután bejelentkezett, kattintson az Új elemre a bal felső sarokban, és keressen rá a Face API kifejezésre, és nyomja le az Enter billentyűt.

    face api keresése

    Megjegyzés

    Előfordulhat, hogy az Új szó helyett a Create a resource(Erőforrás létrehozása) szó lett az újabb portálon.

  3. Az új oldal a Face API szolgáltatás leírását tartalmazza. A parancssor bal alsó részén kattintson a Létrehozás gombra a szolgáltatással való társítás létrehozásához.

    FACE API-információk

  4. Miután rákattintott a Létrehozás gombra:

    1. Szúrja be a szolgáltatáspéldány kívánt nevét.

    2. Válasszon egy előfizetést.

    3. Válassza ki az Önnek megfelelő tarifacsomagot, ha első alkalommal hoz létre Face API-szolgáltatást, egy ingyenes szintnek (F0) kell elérhetőnek lennie.

    4. Válasszon ki egy erőforráscsoportot, vagy hozzon létre egy újat. Az erőforráscsoportokkal monitorzhatja, szabályozhatja a hozzáférést, kiépítheti és kezelheti az Azure-beli eszközök gyűjteményének számlázását. Javasoljuk, hogy egyetlen projekthez (például ezekhez a tesztkörnyezetekhez) társított összes Azure-szolgáltatást egy közös erőforráscsoportban tartsa.

      Ha többet szeretne tudni az Azure-erőforráscsoportokról, tekintse meg az erőforráscsoporttal kapcsolatos cikket.

    5. Az UWP-alkalmazás, a Person Maker, amelyet később fog használni, az USA nyugati régiója helyet igényel.

    6. Azt is meg kell erősítenie, hogy megértette a szolgáltatásra alkalmazott használati feltételeket.

    7. Válassza a Létrehozás lehetőséget.*

      face api szolgáltatás létrehozása

  5. Miután a Létrehozás* gombra kattintott, meg kell várnia a szolgáltatás létrejöttét, ez egy percet is igénybe vehet.

  6. A szolgáltatáspéldány létrehozása után egy értesítés jelenik meg a portálon.

    szolgáltatás-létrehozási értesítés

  7. Kattintson az értesítésekre az új szolgáltatáspéldány felfedezéséhez.

    ugrás az erőforrás-értesítésre

  8. Ha készen áll, kattintson az értesítésben az Ugrás az erőforráshoz gombra az új szolgáltatáspéldány felfedezéséhez.

    face API-kulcsok elérése

  9. Ebben az oktatóanyagban az alkalmazásnak hívásokat kell kezdeményezni a szolgáltatásához, ami a szolgáltatás előfizetési kulcsának használatával történik. A Face API szolgáltatás Gyors kezdőlapján az első pont az 1-es szám, amely a kulcsok le ragadásába fog.

  10. A Szolgáltatás lapon válassza a kék Kulcsok hivatkozást (ha a Gyorsindító lapon van), vagy a Szolgáltatások navigációs menü Kulcsok hivatkozását (a bal oldalon, a "kulcs" ikon jelöli), hogy felfedje a kulcsokat.

    Megjegyzés

    Jegyezze fel valamelyik kulcsot, és őrizze meg, mert később szüksége lesz rá.

2. fejezet – A Person Maker UWP-alkalmazás használata

Töltse le az előre összeállított, Person Makernevű UWP-alkalmazást. Ez az alkalmazás nem ennek a kurzusnak a terméke, csak egy eszköz, amely segít az Azure-bejegyzések létrehozásában, amelyre a későbbi projekt támaszkodik.

A Person Makerrel olyan Azure-bejegyzéseket hozhat létre, amelyek emberekhez és személycsoportokhoz vannak társítva. Az alkalmazás az összes szükséges információt a FaceAPI által később felhasználható formátumban fogja tartalmazni a hozzáadott személyek arcának felismerése érdekében.

[FONTOS] A Person Maker alapszintű szabályozást használ annak érdekében, hogy ne lépje túl a szolgáltatáshívások percenkénti számát az ingyenes előfizetési szinten. A felső zöld szöveg pirosra változik, és a szabályozáskor "AKTÍV" lesz; Ebben az esetben egyszerűen várja meg az alkalmazást (a rendszer megvárja, amíg a továbbiakban hozzá tud férni az arcszolgáltatáshoz, és "IN-ACTIVE" (AKTÍV) lesz, amikor újra használhatja).

Ez az alkalmazás a Microsoft.ProjectOxford.Face kódtárakat használja, amelyek lehetővé teszik a Face API teljes körű használatát. Ez a kódtár ingyenesen elérhető NuGet-csomagként. Az API-król és hasonlókról további információt az API-referenciáról akövetkező cikkben talál: .

Megjegyzés

Ezek csak a szükséges lépések, az ezekhez szükséges utasítások a dokumentum további lépései. A Person Maker alkalmazás a következőt teszi lehetővé:

  • Hozzon létre egy Személycsoportot, amely egy több személyből álló csoport, amelyet hozzá szeretne társítani. Azure-fiókjával több személycsoportot is használhat.

  • Hozzon létre egy Személyt, amely egy Személy csoport tagja. Mindegyik személyhez számos arckép van társítva.

  • Rendeljen arcképeket egy személyhez, hogy az Azure Face API szolgáltatás felismerje a személyt a megfelelő arc alapján.

  • Az Azure Face API szolgáltatás betanítás.

Vegye figyelembe, hogy ahhoz, hogy az alkalmazást betanítsa személyek felismeréséhez, tíz (10) közeli képre lesz szüksége mindegyik személyről, amelyet fel szeretne adni a Személycsoporthoz. A Windows 10 Cam alkalmazás segíthet ezek felvételében. Gondoskodnia kell arról, hogy minden fénykép egyértelmű legyen (ne legyen elmosodva, ne legyen eltévedve, vagy túl távol legyen a tárgytól), jpg vagy png fájlformátumban legyen, és a képfájl mérete ne legyen kisebb 4 MB-nál, és ne legyen kisebb 1 KB-nál.

Megjegyzés

Ha ezt az oktatóanyagot követi, ne használja a saját arcát a betanításhoz, mivel amikor HoloLens, nem használhatja saját magát. Használja egy munkatárs vagy diák arcának használatát.

Running Person Maker:

  1. Nyissa meg a PersonMaker mappát, és kattintson duplán a PersonMaker megoldásra, hogy a következővel Visual Studio.

  2. Ha a PersonMaker megoldás meg van nyitva, győződjön meg a következőről:

    1. A Megoldáskonfiguráció beállítása Hibakeresés.

    2. A Megoldásplatform beállítása x86

    3. A célplatform a helyi gép.

    4. Szükség lehet a NuGet-csomagok visszaállítására is (kattintson a jobb gombbal a Megoldásra, és válassza a NuGet-csomagok visszaállítása lehetőséget).

  3. Kattintson a Helyi gép elemre, és elindul az alkalmazás. Vegye figyelembe, hogy kisebb képernyőken előfordulhat, hogy nem minden tartalom látható, bár a megtekintéshez lejjebb görgethet.

    A person maker felhasználói felülete

  4. Szúrja be az Azure-beli Face API szolgáltatásból a szükséges Azure-beli hitelesítési kulcsot.

  5. Beszúrása:

    1. A Személy csoporthoz hozzárendelni kívánt azonosító. Az azonosítónak kisbetűsnek kell lennie, szóközök nélkül. Jegyezze fel ezt az azonosítót, mert később szükség lesz rá a Unity-projektben.
    2. A Személy csoporthoz hozzárendelni kívánt név (szóközöket is tartalmazhat).
  6. Kattintson a Személycsoport létrehozása gombra. A gomb alatt megerősítő üzenetnek kell megjelennie.

Megjegyzés

Ha "Hozzáférés megtagadva" hibaüzenetet kap, ellenőrizze az Azure-szolgáltatáshoz beállított helyet. Ahogy fent említettük, ez az alkalmazás az USA nyugati régiója számára készült.

Fontos

Figyelje meg, hogy a Fetch a Known Group (Ismert csoport beolvasása) gombra is kattinthat: erre akkor van szükség, ha már létrehozott egy személycsoportot, és nem szeretne újat létrehozni. Vegye figyelembe, hogy ha a Create a Person Group with a known group (Személycsoport létrehozása ismert csoporttal) gombra kattint, az egy csoportot is lekér.

  1. Szúrja be a létrehozni kívánt személy nevét.

    1. Kattintson a Személy létrehozása gombra.

    2. A gomb alatt megerősítő üzenetnek kell megjelennie.

    3. Ha törölni szeretne egy korábban létrehozott személyt, beírhatja a nevet a szövegmezőbe, és megnyomhatja a Személy törlése gombot

  2. Győződjön meg arról, hogy ismeri annak a személynek a helyét, akit fel szeretne adni a csoportjához.

  3. A Create (Létrehozás) és az Open Folder (Mappa megnyitása) Windows explorer megnyitásához a személyhez társított mappához. Adja hozzá a tíz (10) képet a mappához. Ezeknek JPG vagy PNG formátumúnak kell lennie.

  4. Kattintson a Submit to Azure (Küldés az Azure-ba) lehetőségre. A számláló megmutatja a beküldés állapotát, majd egy üzenetet, ha befejeződött.

  5. Ha a számláló befejeződött, és megjelenik egy megerősítő üzenet, kattintson a Betanítás elemre a szolgáltatás betanításhoz.

Ha a folyamat befejeződött, készen áll a Unitybe való áthelyezésre.

3. fejezet – A Unity-projekt beállítása

Az alábbiakban egy tipikus, vegyes valósággal való fejlesztést mutatunk be, és mint ilyen, jó sablon más projektekhez.

  1. Nyissa meg a Unityt, és kattintson a New (Új) elemre.

    Indítsa el az új Unity-projektet.

  2. Most meg kell adnia egy Unity-Project nevét. Szúrja MR_FaceRecognition következőt:. Győződjön meg arról, hogy a projekt típusa 3D. A Hely beállításnál adja meg az Önnek megfelelő helyet (ne feledje, hogy a gyökérkönyvtárakhoz közelebb van a jobb). Ezután kattintson a Projekt létrehozása elemre.

    Adja meg az új Unity-projekt részleteit.

  3. Ha a Unity nyitva van, érdemes ellenőrizni, hogy az alapértelmezett Script Editor értéke Visual Studio. Lépjen az Edit > Preferences (Beállítások szerkesztése) lapra, majd az új ablakban lépjen a External Tools (Külső eszközök) elemre. Módosítsa a Külső szkriptszerkesztőt a Visual Studio 2017-re. Zárja be a Beállítások ablakot.

    A szkriptszerkesztő beállításának frissítése.

  4. Ezután a File > Build Gépház (Build Gépház) menüben váltsa át a platformot a Universal Windows Platform (Univerzális Windows platform) elemre a Switch Platform (Platformváltás) gombra kattintva.

    Build Gépház, váltson platformot UWP-re.

  5. A Fájl > Build Gépház, és győződjön meg a következőről:

    1. A Céleszköz beállítása HoloLens

      A modern headsetek számára a Target Device (Céleszköz) beállításnál adja meg a Any Device (Bármely eszköz) adatokat.

    2. A Build Type (Build típusa) beállítása D3D

    3. Az SDK a Legújabb telepítve beállításra van állítva

    4. Visual Studio Verzió a Legújabb telepítve beállításra van állítva

    5. A Build and Run (Összeállítás és futtatás) beállítása Local Machine (Helyi gép)

    6. Mentse a jelenet, és adja hozzá a buildhez.

      1. Ehhez válassza az Add Open Scenes (Nyitott jelenetek hozzáadása) gombra. Megjelenik egy Mentés ablak.

        Kattintson a Nyitott jelenetek hozzáadása gombra

      2. Válassza az Új mappa gombot egy új mappa létrehozásához, és adja neki a Scenes nevet.

        Új szkriptek mappa létrehozása

      3. Nyissa meg az újonnan létrehozott Scenes mappát, majd a Fájlnév: szövegmezőbe írja be a FaceRecScene nevet, majd nyomja le a Save (Mentés) gombot.

        Adjon nevet az új jelenetnek.

    7. A build Gépház beállításokat az alapértelmezett értéken kell hagynunk.

  6. A Build Gépház ablakban kattintson a Player Gépház gombra, ezzel megnyitja a kapcsolódó panelt abban a térben, ahol az Inspector található.

    Nyissa meg a lejátszó beállításait.

  7. Ezen a panelen ellenőrizni kell néhány beállítást:

    1. Az Egyéb Gépház lapon:

      1. A parancsprogram-futtatás verziójának kísérletinek kell lennie (.NET 4.6-os megfelelő). Ha ezt módosítja, a szerkesztőt újra kell indítania.

      2. A parancsfájl-háttérrendszernek .NET-nek kell lennie

      3. Az API-kompatibilitási szint legyen .NET 4.6

        Frissítse az egyéb beállításokat.

    2. A Közzététel lap Képességek Gépház alatt ellenőrizze a következőt:

      • InternetClient

      • Webkamera

        Közzétételi beállítások frissítése.

    3. A panelen lejjebb, az XR Gépház (a Publish Gépház(Közzététel) alatt) jelölje be a Virtual Reality supported (Virtuális valóság támogatott) jelölőnégyzetet, és győződjön meg arról, hogy az Windows Mixed Reality SDK hozzá van adva.

      Frissítse az X R-Gépház.

  8. A Build Gépház visszatérve a Unity C# Projects már nem szürkül ki; jelölje be a mellette jelölőnégyzetet.

  9. Zárja be a Build Gépház ablakot.

  10. Mentse a Scene and Project (FILE > SAVE SCENE / FILE > SAVE PROJECT ( A SAVE PROJECT (> SAVE PROJECT )(> SAVE SCENE /FILE)) fájlt.

4. fejezet – A Main Camera beállítása

Fontos

Ha ki szeretné hagyni ennek a kurzusnak a Unity Set up összetevőjét, és közvetlenül a kódba szeretne ugrani, töltse le ezt a .unitypackagecsomagot, és importálja a projektbe Egyéni csomagként. Vegye figyelembe, hogy ez a csomag az 5. fejezetben szereplő Newtonsoft DLL importálását is tartalmazza. Az importálás után folytathatja a 6. fejezetet.

  1. A Hierarchia panelen válassza a Main Camera (Fő kamera) lehetőséget.

  2. Miután kiválasztotta, a Main Camera összes összetevője jelölve lesz az Inspector panelen.

    1. A Camera objektumnak Main Camera (Main Camera) nevet kell adnunk (jegyezze fel a helyesírást!)

    2. A Main Camera Tag (Main Camera Tag) címkét MainCamera (jegyezze fel a helyesírást!)

    3. Győződjön meg arról, hogy az Átalakítás pozíciója 0, 0, 0

    4. A Clear Flags (Jelzők ürítője) beállítása Folytonos színre

    5. Állítsa a kamera-összetevő háttérszínét Fekete, Alfa 0 (Hexikus kód: #00000000)

      kamera-összetevők beállítása

5. fejezet – A Newtonsoft.Jsimportálása a könyvtárba

Fontos

Ha az előző fejezetben importálta a .unitypackage et, kihagyhatja ezt a fejezetet.

Ha segítségre van szüksége a fogadott és a Bot Service küldött objektumok de szerializálásához és szerializálásához, le kell töltenie aNewtonsoft.Js könyvtárba. Ebben a Unity-csomagfájlban egy már a megfelelő Unity-mappastruktúrával rendszerezhető verzió található.

A kódtár importálása:

  1. Töltse le a Unity-csomagot.

  2. Kattintson az Assets (Eszközök), Import Package (Csomag importálása) és Custom Package (Egyéni csomag) elemre.

    Importálás Newtonsoft.Jsbe

  3. Keresse meg a letöltött Unity-csomagot, és kattintson az Open (Megnyitás) gombra.

  4. Győződjön meg arról, hogy a csomag összes összetevője pipálva van, és kattintson az Importálás gombra.

    Adateszközök Newtonsoft.Jsimportálása

6. fejezet – A FaceAnalysis osztály létrehozása

A FaceAnalysis osztály célja az Azure Face Recognition Service-sel való kommunikációhoz szükséges metódusok kiszolgálása.

  • Miután elküldte a szolgáltatásnak a rögzítési képet, meg fogja állapítani, hogy a képen látható arcok megjelennek-e, és megállapítja, hogy van-e ismert személy.
  • Ha talál egy ismert személyt, ez az osztály felhasználói felületi szövegként jeleníti meg a nevét a jelenetben.

A FaceAnalysis osztály létrehozása:

  1. Kattintson a jobb gombbal az Assets mappára a Project panelen, majd kattintson a Create Folder (Mappa > létrehozása) elemre. Hívja meg a scripts mappát.

    Hozza létre a FaceAnalysis osztályt.

  2. Kattintson duplán a most létrehozott mappára a megnyitásához.

  3. Kattintson a jobb gombbal a mappában, majd kattintson a > Create C# Script (C#-szkript létrehozása) parancsra. Hívja meg a FaceAnalysis szkriptet.

  4. Kattintson duplán az új FaceAnalysis szkriptre a 2017-es Visual Studio megnyitásához.

  5. Adja meg a következő névtereket a FaceAnalysis osztály felett:

        using Newtonsoft.Json;
        using System.Collections;
        using System.Collections.Generic;
        using System.IO;
        using System.Text;
        using UnityEngine;
        using UnityEngine.Networking;
    
  6. Most hozzá kell adni a deerializáláshoz használt összes objektumot. Ezeket az objektumokat a FaceAnalysis szkripten kívül kell hozzáadni (az alsó gólyos zárójel alatt).

        /// <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; }
        }
    
  7. A Start() és az Update() metódusok nem lesznek használva, ezért most törölje őket.

  8. A FaceAnalysis osztályban adja hozzá a következő változókat:

        /// <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 -";
    

    Megjegyzés

    Cserélje le a kulcsot és a personGroupId azonosítót a szolgáltatáskulcsra és a korábban létrehozott csoport azonosítójára.

  9. Adja hozzá az osztály inicializálását lehetővé t tő, az ImageCapture osztályt a Main Camera osztályhoz, majd hívja meg a Label creation metódust:

        /// <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();
        }
    
  10. Adja hozzá a CreateLabel() metódust, amely létrehozza a Label objektumot az elemzési eredmény megjelenítéséhez:

        /// <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 = ".";       
        }
    
  11. Adja hozzá a DetectFacesFromImage() és a GetImageAsByteArray() metódust. Az előbbi kérni fogja a Face Recognition Service-t, hogy észlelje a lehetséges arcokat a beküldött képen, míg az utóbbi szükséges a rögzített kép bájttömbbe való átalakításához:

        /// <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);
        }
    
  12. Adja hozzá az IdentifyFaces() metódust, amely a Face Recognition Service-t a beküldött képen korábban észlelt ismert arcok azonosítására kéri. A kérelem az azonosított személy azonosítóját adja vissza, a nevet azonban nem:

        /// <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);
                }           
            }
        }
    
  13. Adja hozzá a GetPerson() metódust. A személyazonosító megszabadával ez a metódus a Face Recognition Service-nek az azonosított személy nevét adja vissza:

        /// <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;
            }
        }
    
  14. Ne felejtse el menteni a módosításokat, mielőtt visszatér a Unity-szerkesztőbe.

  15. A Unity-szerkesztőben húzza a FaceAnalysis szkriptet a Project Scripts mappából a Hierarchy panel Main Camera objektumába. Az új szkriptösszetevő így hozzá lesz adva a Main Camera-hoz.

FaceAnalysis helyezése a Main Camera-ra

7. fejezet – Az ImageCapture osztály létrehozása

Az ImageCapture osztály célja, hogy az Azure Face Recognition Service-sel való kommunikációhoz szükséges metódusokat használja a rögzítendő kép leképezéséhez, az arcok azonosításához és annak meghatározásához, hogy egy ismert személyhez tartozik-e. Ha talál egy ismert személyt, ez az osztály felhasználói felületi szövegként jeleníti meg a nevét a jelenetben.

Az ImageCapture osztály létrehozása:

  1. Kattintson a jobb gombbal a korábban létrehozott Scripts mappában, majd kattintson a Létrehozás, C# szkript elemre. Hívja meg az ImageCapture szkriptet.

  2. Kattintson duplán az új ImageCapture-szkriptre a 2017-es Visual Studio megnyitásához.

  3. Adja meg a következő névtereket az ImageCapture osztály felett:

        using System.IO;
        using System.Linq;
        using UnityEngine;
        using UnityEngine.XR.WSA.Input;
        using UnityEngine.XR.WSA.WebCam;
    
  4. Az ImageCapture osztályon belül adja hozzá a következő változókat:

        /// <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;
    
  5. Adja hozzá az osztály inicializálása és a HoloLens a felhasználó kézmozdulatának rögzítéséhez szükséges Egyek() és Start() metódusokat:

        /// <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();
        }
    
  6. Adja hozzá a TapHandler() et, amelyet a rendszer akkor hív meg, amikor a felhasználó koppintásos kézmozdulatot hajt végre:

        /// <summary>
        /// Respond to Tap Input.
        /// </summary>
        private void TapHandler(TappedEventArgs obj)
        {
            tapsCount++;
            ExecuteImageCaptureAndAnalysis();
        }
    
  7. Adja hozzá az ExecuteImageCaptureAndAnalysis() metódust, amely megkezdi a képrögzítés folyamatát:

        /// <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);
                });
            });
        }
    
  8. Adja hozzá a fényképrögzítési folyamat befejezésekor hívható kezelőket:

        /// <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());
        }
    
  9. Ne felejtse el menteni a módosításokat, mielőtt visszatér a Unity-szerkesztőbe.

8. fejezet – A megoldás kiépítése

Az alkalmazás alapos tesztelésének elvégzéséhez közvetlenül kell azt a saját HoloLens.

Mielőtt ezt meghozta, győződjön meg a következőről:

  • A 3. fejezetben említett beállítások megfelelően vannak beállítva.
  • A FaceAnalysis szkript a Main Camera objektumhoz van csatolva.
  • Az Auth-kulcs és a csoportazonosító is be van állítva a FaceAnalysis-szkriptben.

Most már készen áll a Megoldás építésre. A megoldás elkészülte után készen áll az alkalmazás üzembe helyezésére.

A buildfolyamat megkezdéséhez:

  1. Mentse az aktuális jelenet a Fájl, Mentés gombra kattintva.

  2. Nyissa meg a File (Fájl) build Gépház, majd a Add Open Scenes (Nyitott jelenetek hozzáadása) gombra.

  3. Győződjön meg arról, hogy a Unity C# Projects órajelet ad meg.

    A Visual Studio üzembe helyezése

  4. Nyomja le a Build (Build) gombot. Ekkor a Unity elindít egy Fájlkezelő, amelyben létre kell hoznia, majd ki kell választania egy mappát, amelybe az alkalmazást felépíti. Hozza létre ezt a mappát most a Unity-projektben, és hívja appnak. Ezután jelölje ki az Alkalmazás mappát, és kattintson a Mappa kiválasztása gombra.

  5. A Unity megkezdi a projekt építését az App mappában.

  6. Miután a Unity befejezte az összeállítást (ez némi időt is Fájlkezelő, megnyílik egy ablak a build helyén.

    A megoldás üzembe helyezése a Visual Studio

  7. Nyissa meg az App mappát, majd nyissa meg az új Project Solution (Megoldás) (lásd fent, MR_FaceRecognition.sln).

9. fejezet – Az alkalmazás üzembe helyezése

Üzembe helyezés a következő HoloLens:

  1. A távoli üzembe helyezéshez szüksége lesz a HoloLens IP-címére, és annak biztosításához, hogy HoloLens módban legyen. Ehhez tegye a következőket:

    1. Bár a saját HoloLens, nyissa meg a Gépház.
    2. Ugrás a Hálózati & Internet > Wi-Fi > Speciális beállítások elemre
    3. Jegyezze fel az IPv4-címet.
    4. Ezután lépjen vissza a Gépház, majd az Update & Security > for Developers (Biztonsági beállítások frissítése fejlesztőknek) lapra.
    5. Állítsa be a Fejlesztői módot.
  2. Lépjen az új Unity-buildre (az App mappára), és nyissa meg a megoldásfájlt a Visual Studio.

  3. A Megoldáskonfigurációban válassza a Hibakeresés lehetőséget.

  4. A Megoldásplatformon válassza az x86, távoli gép lehetőséget.

    A megoldás konfigurációjának módosítása

  5. A Build (Build) menüben kattintson a Deploy Solution(Megoldás üzembe helyezése) elemre az alkalmazás saját HoloLens.

  6. Az alkalmazásnak meg kell jelenni a telepített alkalmazások listájában a HoloLens, készen áll az indulásra!

Megjegyzés

A modern headsetben való üzembe helyezéshez állítsa a Megoldásplatformot helyi gépre, a konfigurációt pedig hibakeresési beállításra, platformként pedig az x86-ot. Ezután telepítse az elemet a helyi gépen a Build (Összeállítás) menüben a Deploy Solution (Megoldás üzembe helyezése) lehetőség kiválasztásával.

10. fejezet – Az alkalmazás használata

  1. Az alkalmazás HoloLens indítsa el az alkalmazást.

  2. Nézze meg a Face API-ban regisztrált személyt. Ügyeljen a következőkre:

    • A személy arca nem túl távoli és jól látható
    • A környezet megvilágítása nem túl sötét
  3. A koppintásos kézmozdulattal rögzítheti a személy képét.

  4. Várjon, amíg az alkalmazás elküldi az elemzési kérést, és megkapja a választ.

  5. Ha a személy sikeresen fel lett ismerve, a személy neve felhasználói felületi szövegként fog megjelenni.

  6. Néhány másodpercenként a koppintásos kézmozdulattal megismételheti a rögzítési folyamatot.

A kész Azure Face API-alkalmazás

Gratulálunk, felépített egy vegyes valóságú alkalmazást, amely az Azure Face Recognition szolgáltatást használja a képeken belüli arcok észlelésére és az ismert arcok azonosítására.

a kurzus befejezésének eredménye

Soron kívüli gyakorlatok

1. gyakorlat

Az Azure Face API elég hatékony ahhoz, hogy egyetlen képen legfeljebb 64 arcot észlelje. Terjessze ki az alkalmazást, hogy felismerje két vagy három arcot, sok más ember között.

2. gyakorlat

Az Azure Face API bármilyen attribútuminformációt vissza tud adni. Ezt integrálja az alkalmazásba. Ez még érdekesebb lehet az Emotion API-val kombinálva.