Sdílet prostřednictvím

HoloLens (1. generace) a Azure 304: Rozpoznávání tváře

  • Článek

Poznámka:

Kurzy Mixed Reality Academy byly navrženy s HoloLensem (1. generace) a imerzivními náhlavními soupravami hybridní reality. Proto máme pocit, že je důležité nechat tyto kurzy zavedené pro vývojáře, kteří stále hledají pokyny při vývoji těchto zařízení. Tyto kurzy nebudou aktualizovány nejnovějšími sadami nástrojů ani interakcemi používanými pro HoloLens 2. Budou zachovány, aby pokračovaly v práci na podporovaných zařízeních. Bude k dispozici nová série kurzů, které budou publikovány v budoucnu, které předvádějí, jak vyvíjet pro HoloLens 2. Toto oznámení se při publikování aktualizuje odkazem na tyto kurzy.


výsledek dokončení tohoto kurzu

V tomto kurzu se dozvíte, jak přidat možnosti rozpoznávání tváře do aplikace hybridní reality pomocí služeb Azure Cognitive Services s rozhraním MICROSOFT API pro rozpoznávání tváře.

Azure Face API je služba Microsoftu, která vývojářům poskytuje nejpokročilejší algoritmy pro rozpoznávání tváře, a to vše v cloudu. Rozhraní API pro rozpoznávání tváře má dvě hlavní funkce: rozpoznávání tváře s atributy a rozpoznávání tváře. Vývojáři tak můžou jednoduše nastavit skupinu skupin pro tváře a pak později odeslat obrázky dotazů do služby, aby určili, komu tvář patří. Další informace najdete na stránce Azure Rozpoznávání tváře.

Po dokončení tohoto kurzu budete mít aplikaci HoloLens pro hybridní realitu, která bude moct provést následující akce:

  1. Pomocí gesta klepnutím zahájíte zachycení obrázku pomocí kamery HoloLens na palubě.
  2. Odešle zachycenou image do služby Rozhraní API pro rozpoznávání tváře Azure.
  3. Získejte výsledky algoritmu rozhraní API pro rozpoznávání tváře.
  4. Pomocí jednoduchého uživatelského rozhraní můžete zobrazit jméno odpovídajících osob.

Naučíte se, jak získat výsledky ze služby ROZHRANÍ API pro rozpoznávání tváře do aplikace hybridní reality založené na Unity.

V aplikaci je na vás, jak integrovat výsledky s návrhem. Tento kurz je navržený tak, aby vás naučil, jak integrovat službu Azure s projektem Unity. Vaším úkolem je využít znalosti získané z tohoto kurzu k vylepšení aplikace hybridní reality.

Podpora zařízení

Kurz HoloLens Imerzivní náhlavní soupravy
MR a Azure 304: Rozpoznávání tváře ✔️ ✔️

Poznámka:

I když se tento kurz primárně zaměřuje na HoloLens, můžete také použít to, co se v tomto kurzu naučíte, na imerzivní náhlavní soupravy Windows Mixed Reality (VR). Vzhledem k tomu, že imerzivní náhlavní soupravy (VR) nemají přístupné kamery, budete potřebovat externí kameru připojenou k počítači. Jak budete postupovat podle kurzu, uvidíte poznámky o všech změnách, které možná budete muset použít pro podporu imerzivních náhlavních souprav (VR).

Požadavky

Poznámka:

Tento kurz je určený pro vývojáře, kteří mají základní zkušenosti s Unity a C#. Mějte také na paměti, že požadavky a písemné pokyny v tomto dokumentu představují to, co bylo otestováno a ověřeno v době psaní (květen 2018). Můžete používat nejnovější software, jak je uvedeno v článku o instalaci nástrojů , i když by se nemělo předpokládat, že informace v tomto kurzu budou dokonale odpovídat tomu, co najdete v novějším softwaru, než je uvedeno níže.

Pro tento kurz doporučujeme následující hardware a software:

Než začnete

  1. Abyste se vyhnuli problémům při sestavování tohoto projektu, důrazně doporučujeme vytvořit projekt uvedený v tomto kurzu v kořenové nebo téměř kořenové složce (dlouhé cesty ke složkám můžou způsobovat problémy v době sestavení).
  2. Nastavte a otestujte HoloLens. Pokud potřebujete podporu k nastavení HoloLens, nezapomeňte navštívit článek o nastavení HoloLens.
  3. Při vývoji nové aplikace HoloLens je vhodné provést kalibraci a ladění senzorů (někdy může pomoct tyto úlohy provádět pro každého uživatele).

Nápovědu k kalibraci najdete v tomto odkazu na článek o kalibraci HoloLens.

Nápovědu k ladění senzorů najdete v tomto odkazu na článek o ladění snímačů HoloLens.

Kapitola 1 – Azure Portal

Pokud chcete používat službu rozhraní API pro rozpoznávání tváře v Azure, budete muset nakonfigurovat instanci služby, aby byla dostupná pro vaši aplikaci.

  1. Nejprve se přihlaste k webu Azure Portal.

    Poznámka:

    Pokud ještě nemáte účet Azure, budete ho muset vytvořit. Pokud tento kurz sledujete v situaci v učebně nebo testovacím prostředí, požádejte svého instruktora nebo některého z proktorů, aby vám pomohli nastavit nový účet.

  2. Po přihlášení klikněte v levém horním rohu na Nový a vyhledejte rozhraní API pro rozpoznávání tváře, stiskněte Enter.

    vyhledání rozhraní API pro rozpoznávání tváře

    Poznámka:

    Slovo Nový mohlo být nahrazeno vytvořením prostředku na novějších portálech.

  3. Na nové stránce se zobrazí popis služby rozhraní API pro rozpoznávání tváře. V levém dolním rohu této výzvy vyberte tlačítko Vytvořit a vytvořte přidružení k této službě.

    Informace o rozhraní API pro rozpoznávání tváře

  4. Po kliknutí na Vytvořit:

    1. Vložte požadovaný název pro tuto instanci služby.

    2. Vyberte předplatné.

    3. Vyberte cenovou úroveň, která je pro vás vhodná, pokud se jedná o první vytvoření služby rozhraní API pro rozpoznávání tváře, měla by vám být k dispozici bezplatná úroveň (s názvem F0).

    4. Zvolte skupinu prostředků nebo vytvořte novou. Skupina prostředků poskytuje způsob, jak monitorovat, řídit přístup, zřizovat a spravovat fakturaci pro kolekci prostředků Azure. Doporučujeme zachovat všechny služby Azure přidružené k jednomu projektu (například k těmto testovacím prostředím) v rámci společné skupiny prostředků).

      Pokud si chcete přečíst další informace o skupinách prostředků Azure, navštivte prosím článek o skupině prostředků.

    5. Aplikace UPW, Person Maker, kterou použijete později, vyžaduje použití oblasti USA – západ pro umístění.

    6. Budete také muset potvrdit, že jste porozuměli podmínkám a ujednáním použitým pro tuto službu.

    7. Vyberte Vytvořit.*

      Vytvoření služby api pro rozpoznávání tváře

  5. Jakmile kliknete na Vytvořit,* budete muset počkat na vytvoření služby, může to chvíli trvat.

  6. Po vytvoření instance služby se na portálu zobrazí oznámení.

    Oznámení o vytvoření služby

  7. Kliknutím na oznámení můžete prozkoumat novou instanci služby.

    Přejít na oznámení o prostředku

  8. Až budete připraveni, klikněte v oznámení na tlačítko Přejít k prostředku a prozkoumejte novou instanci služby.

    přístup ke klíčům rozhraní API pro rozpoznávání tváře

  9. V tomto kurzu bude vaše aplikace muset volat vaši službu, která se provádí pomocí klíče předplatného vaší služby. Na úvodní stránce služby rozhraní API pro rozpoznávání tváře je prvním bodem číslo 1, abyste mohli klíče pořídit.

  10. Na stránce Služba vyberte buď modrý hypertextový odkaz Klíče (pokud je na stránce Rychlý start), nebo odkaz Klíče v navigační nabídce služeb (vlevo, označený ikonou klíče), aby se vaše klíče zobrazily.

    Poznámka:

    Poznamenejte si jeden z klíčů a zabezpečte ho, protože ho budete potřebovat později.

Kapitola 2 – Použití aplikace "Person Maker" pro UPW

Nezapomeňte stáhnout předem připravenou aplikaci upW s názvem Person Maker. Tato aplikace není koncovým produktem pro tento kurz, což je nástroj, který vám pomůže vytvořit položky Azure, na které bude pozdější projekt záviset.

Tvůrce osob umožňuje vytvářet položky Azure, které jsou přidružené k lidem a skupinám osob. Aplikace umístí všechny potřebné informace do formátu, který pak může později používat FaceAPI, aby rozpoznal tváře lidí, které jste přidali.

[DŮLEŽITÉ] Služba Person Maker používá základní omezení, aby se zajistilo, že nepřekročíte počet volání služeb za minutu pro úroveň bezplatného předplatného. Zelený text v horní části se změní na červenou a při omezování se aktualizuje jako AKTIVNÍ. Pokud se jedná o tento případ, jednoduše počkejte na aplikaci (bude čekat, až bude moct dál přistupovat ke službě rozpoznávání tváře, aktualizovat ji jako IN-ACTIVE, až ji budete moct znovu použít).

Tato aplikace používá knihovny Microsoft.ProjectOxford.Face , které vám umožní plně využívat rozhraní API pro rozpoznávání tváře. Tato knihovna je k dispozici zdarma jako balíček NuGet. Další informace o těchto a podobných rozhraních API najdete v referenčním článku k rozhraní API.

Poznámka:

Toto jsou jenom požadované kroky, pokyny k tomu, jak tyto věci provést, jsou dále v dokumentu. Aplikace Person Maker vám umožní:

  • Vytvořte skupinu osob, což je skupina složená z několika lidí, které k ní chcete přidružit. Pomocí svého účtu Azure můžete hostovat více skupin osob.

  • Vytvořte osobu, která je členem skupiny osob. Každá osoba má k němu přidružených několik obrázků tváří .

  • Přiřaďte k osobě obrázky tváří, aby služba Azure API pro rozpoznávání tváře rozpoznala osobu podle odpovídající tváře.

  • Trénujte službu Rozhraní API pro rozpoznávání tváře Azure.

Mějte na paměti, že pokud chcete tuto aplikaci vytrénovat tak, aby rozpoznávala lidi, budete potřebovat deset (10) detailních fotek každé osoby, kterou chcete přidat do skupiny osob. Aplikace Windows 10 Cam vám může pomoct s jejich pořízením. Musíte zajistit, aby každá fotografie byla jasná (vyhněte se rozmazaní, obskurzování nebo příliš daleko od předmětu), mít fotku ve formátu jpg nebo png, přičemž velikost souboru obrázku není větší 4 MB a ne méně než 1 kB.

Poznámka:

Pokud sledujete tento kurz, nepoužívejte pro trénování vlastní tvář, jako když jste holoLens nasadili, nemůžete se na sebe podívat. Použijte tvář kolegy nebo kolegy.

Spuštění tvůrce osob:

  1. Otevřete složku PersonMaker a poklikáním otevřete řešení PersonMaker v sadě Visual Studio.

  2. Jakmile je řešení PersonMaker otevřené, ujistěte se, že:

    1. Konfigurace řešení je nastavená na Ladění.

    2. Platforma řešení je nastavená na x86.

    3. Cílová platforma je místní počítač.

    4. Možná budete také muset obnovit balíčky NuGet (klikněte pravým tlačítkem na řešení a vyberte Obnovit balíčky NuGet).

  3. Klikněte na Místní počítač a aplikace se spustí. Mějte na paměti, že na menších obrazovkách nemusí být veškerý obsah viditelný, i když se můžete posunout dolů a zobrazit ho.

    uživatelské rozhraní pro tvůrce osob

  4. Vložte ověřovací klíč Azure, který byste měli mít, ze služby rozhraní API pro rozpoznávání tváře v Rámci Azure.

  5. Vložit:

    1. ID, které chcete přiřadit skupině osob. ID musí být malými písmeny bez mezer. Poznamenejte si toto ID, protože se bude vyžadovat později v projektu Unity.
    2. Jméno, které chcete přiřadit skupině osob (může obsahovat mezery).

  6. Stiskněte tlačítko Vytvořit skupinu osob. Pod tlačítkem by se měla zobrazit potvrzovací zpráva.

Poznámka:

Pokud dojde k chybě Odepření přístupu, zkontrolujte umístění, které jste nastavili pro službu Azure. Jak je uvedeno výše, tato aplikace je navržená pro usa – západ.

Důležité

Všimněte si, že můžete také kliknout na tlačítko Načíst známou skupinu : to znamená, pokud jste už vytvořili skupinu osob a chcete ji použít, a ne vytvořit novou skupinu. Upozorňujeme, že pokud kliknete na Vytvořit skupinu osob se známou skupinou, načte se také skupina.

  1. Vložte jméno osoby, kterou chcete vytvořit.

    1. Klikněte na tlačítko Vytvořit osobu .

    2. Pod tlačítkem by se měla zobrazit potvrzovací zpráva.

    3. Pokud chcete odstranit osobu, kterou jste vytvořili dříve, můžete napsat jméno do textového pole a stisknout klávesu Delete Person.

  2. Ujistěte se, že znáte umístění deseti (10) fotek osoby, kterou chcete přidat do skupiny.

  3. Stisknutím klávesy Create and Open Folder (Vytvořit a otevřít složku ) otevřete Průzkumníka Windows do složky přidružené k dané osobě. Přidejte do složky deset (10) obrázků. Musí to být formát souboru JPG nebo PNG .

  4. Klikněte na Odeslat do Azure. Čítač zobrazí stav odeslání a po jeho dokončení se zobrazí zpráva.

  5. Jakmile se čítač dokončí a zobrazí se potvrzovací zpráva, klikněte na trénovat službu.

Po dokončení procesu můžete přejít do Unity.

Kapitola 3 – Nastavení projektu Unity

Následuje typická sada pro vývoj s hybridní realitou a jako taková je vhodná šablona pro jiné projekty.

  1. Otevřete Unity a klikněte na Nový.

    Spusťte nový projekt Unity.

  2. Teď budete muset zadat název projektu Unity. Vložit MR_FaceRecognition Ujistěte se, že je typ projektu nastavený na 3D. Nastavte umístění na místo, které je pro vás vhodné (nezapomeňte, že blíže ke kořenovým adresářům je lepší). Potom klikněte na Vytvořit projekt.

    Zadejte podrobnosti o novém projektu Unity.

  3. Při otevření Unity stojí za to zkontrolovat, jestli je výchozí editor skriptů nastavený na Visual Studio. Přejděte na Upravit předvolby a pak v novém okně přejděte na Externí nástroje. > Změňte editor externích skriptů na Visual Studio 2017. Zavřete okno Předvolby.

    Aktualizujte předvolbu editoru skriptů.

  4. Dále přejděte do Nastavení sestavení souborů > a přepněte platformu na Univerzální platforma Windows kliknutím na tlačítko Přepnout platformu.

    Okno Nastavení sestavení, přepnutí platformy na UPW

  5. Přejděte do nastavení sestavení souborů > a ujistěte se, že:

    1. Cílové zařízení je nastavené na HoloLens.

      U imerzivních náhlavních souprav nastavte cílové zařízení na libovolné zařízení.

    2. Typ sestavení je nastavený na D3D.

    3. Sada SDK je nastavená na nejnovější nainstalovanou verzi.

    4. Verze sady Visual Studio je nastavená na nejnovější nainstalovanou verzi.

    5. Sestavení a spuštění je nastavené na místní počítač.

    6. Uložte scénu a přidejte ji do sestavení.

      1. Uděláte to tak, že vyberete Přidat otevřené scény. Zobrazí se okno pro uložení.

        Kliknutí na tlačítko Pro přidání otevřených scén

      2. Vyberte tlačítko Nová složka a vytvořte novou složku a pojmenujte ji Scény.

        Vytvoření nové složky skriptů

      3. Otevřete nově vytvořenou složku Scény a pak v názvu souboru: textové pole, zadejte FaceRecScene a stiskněte Uložit.

        Pojmenujte novou scénu.

    7. Zbývající nastavení v nastavení sestavení by teď měla zůstat ve výchozím nastavení.

  6. V okně Nastavení sestavení klikněte na tlačítko Nastavení přehrávače, otevře se související panel v prostoru, kde se nachází inspektor.

    Otevřete nastavení přehrávače.

  7. Na tomto panelu je potřeba ověřit několik nastavení:

    1. Na kartě Další nastavení:

      1. Skriptovací verze modulu runtime by měla být experimentální (ekvivalent .NET 4.6). Změnou této změny se aktivuje potřeba restartovat Editor.

      2. Back-end skriptování by měl být .NET.

      3. Úroveň kompatibility rozhraní API by měla být .NET 4.6

        Aktualizujte další nastavení.

    2. Na kartě Nastavení publikování v části Možnosti zaškrtněte:

      • InternetClient

      • Webová kamera

        Aktualizace nastavení publikování

    3. Dále na panelu v nastavení XR (v části Nastavení publikování níže) zaškrtněte možnost Podpora virtuální reality a ujistěte se, že je přidaná sada SDK pro Windows Mixed Reality.

      Aktualizujte nastavení X R.

  8. Zpět v nastavení sestavení už projekty Unity C# nejsou šedé. Zaškrtněte políčko vedle tohoto nastavení.

  9. Zavřete okno Nastavení sestavení.

  10. Uložte scénu a projekt (FILE SAVE SCENE / FILE > > SAVE PROJECT).

Kapitola 4 - Nastavení hlavní kamery

Důležité

Pokud chcete přeskočit komponentu Nastavení Unity v tomto kurzu a pokračovat přímo do kódu, můžete si stáhnout tento balíček .unitypackage a importovat ho do projektu jako vlastní balíček. Mějte na paměti, že tento balíček zahrnuje také import Newtonsoft DLL, který je popsán v kapitole 5. S tímto importem můžete pokračovat z kapitoly 6.

  1. Na panelu hierarchie vyberte hlavní kameru.

  2. Po výběru uvidíte všechny součásti hlavní kamery na panelu inspektoru.

    1. Objekt Fotoaparát musí mít název Hlavní kamera (všimněte si pravopisu!)

    2. Hlavní značka fotoaparátu musí být nastavená na MainCamera (všimněte si pravopisu!)

    3. Ujistěte se, že je pozice transformace nastavená na hodnotu 0, 0, 0.

    4. Nastavení jasných příznaků na plnou barvu

    5. Nastavte barvu pozadí komponenty fotoaparátu na černou, alfa 0 (šestnáctkový kód: #00000000)

      nastavení komponent fotoaparátu

Kapitola 5 – Import knihovny Newtonsoft.Json

Důležité

Pokud jste importovali soubor .unitypackage v poslední kapitole, můžete tuto kapitolu přeskočit.

Abyste mohli deserializovat a serializovat objekty přijaté a odeslané do služby Bot Service, musíte stáhnout knihovnu Newtonsoft.Json . V tomto souboru balíčku Unity najdete kompatibilní verzi, která už je uspořádaná se správnou strukturou složek Unity.

Import knihovny:

  1. Stáhněte si balíček Unity.

  2. Klikněte na prostředky, importovat balíček, vlastní balíček.

    Import Newtonsoft.Json

  3. Vyhledejte balíček Unity, který jste stáhli, a klikněte na Otevřít.

  4. Ujistěte se, že jsou zaškrtnuté všechny součásti balíčku, a klikněte na Importovat.

    Import prostředků Newtonsoft.Json

Kapitola 6 – Vytvoření třídy FaceAnalysis

Účelem třídy FaceAnalysis je hostovat metody potřebné ke komunikaci se službou Azure Rozpoznávání tváře.

  • Po odeslání zachyceného obrázku služba ho analyzuje a identifikuje tváře uvnitř a určí, jestli některé patří známé osobě.
  • Pokud se najde známá osoba, zobrazí tato třída její název jako text uživatelského rozhraní ve scéně.

Vytvoření třídy FaceAnalysis:

  1. Klikněte pravým tlačítkem na složku Assets v panelu projektu a potom klikněte na Vytvořit>složku. Volejte skripty složky.

    Vytvořte třídu FaceAnalysis.

  2. Poklikáním na právě vytvořenou složku otevřete.

  3. Klikněte pravým tlačítkem myši do složky a potom klikněte na Vytvořit>skript jazyka C#. Volání skriptu FaceAnalysis

  4. Poklikáním otevřete nový skript FaceAnalysis v sadě Visual Studio 2017.

  5. Zadejte následující obory názvů nad třídou FaceAnalysis :

        using Newtonsoft.Json;
    using System.Collections;
    using System.Collections.Generic;
    using System.IO;
    using System.Text;
    using UnityEngine;
    using UnityEngine.Networking;

  6. Teď musíte přidat všechny objekty, které se používají k deserialisování. Tyto objekty je potřeba přidat mimo skript FaceAnalysis (pod dolní složenou závorku).

        /// <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. Metody Start() a Update() se nebudou používat, proto je odstraňte.

  8. Do třídy FaceAnalysis přidejte následující proměnné:

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

    Poznámka:

    Nahraďte klíč a personGroupId klíčem služby a ID skupiny, kterou jste vytvořili dříve.

  9. Přidejte metodu Awake(), která inicializuje třídu, přidání ImageCapture třídy do Main Camera a zavolá metodu vytvoření popisku:

        /// <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. Přidejte metodu CreateLabel(), která vytvoří objekt Label pro zobrazení výsledku analýzy:

        /// <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. Přidejte metodu DetectFacesFromImage() a GetImageAsByteArray(). První požádá službu rozpoznávání tváře, aby detekovala jakoukoli možnou tvář na odeslaném obrázku, zatímco druhá možnost je nutná k převodu zachyceného obrázku na pole bajtů:

        /// <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. Přidejte metodu IdentifyFaces(), která požádá službu rozpoznávání tváře, aby identifikovala jakoukoli známou tvář, která byla dříve zjištěna na odeslaném obrázku. Žádost vrátí ID identifikované osoby, ale ne jméno:

        /// <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. Přidejte metodu GetPerson(). Když zadáte ID osoby, tato metoda pak požádá službu rozpoznávání tváře, aby vrátila jméno identifikované osoby:

        /// <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ž se vrátíte do Unity Editoru, nezapomeňte změny uložit .

  15. V Unity Editoru přetáhněte skript FaceAnalysis ze složky Scripts na panelu Projektu do objektu Hlavní kamera na panelu Hierarchie. Nová komponenta skriptu bude přidána do hlavní kamery.

Umístit FaceAnalysis na hlavní kameru

Kapitola 7 – Vytvoření třídy ImageCapture

Účelem třídy ImageCapture je hostovat metody potřebné ke komunikaci se službou Azure Rozpoznávání tváře k analýze obrázku, který budete zaznamenávat, identifikovat tváře v ní a určit, jestli patří známé osobě. Pokud se najde známá osoba, zobrazí tato třída její název jako text uživatelského rozhraní ve scéně.

Vytvoření třídy ImageCapture:

  1. Klikněte pravým tlačítkem do složky Skripty , kterou jste vytvořili dříve, a potom klikněte na Příkaz Vytvořit, Skript jazyka C#. Volání skriptu ImageCapture.

  2. Poklikáním otevřete nový skript ImageCapture v sadě Visual Studio 2017.

  3. Nad třídou ImageCapture zadejte následující obory názvů:

        using System.IO;
    using System.Linq;
    using UnityEngine;
    using UnityEngine.XR.WSA.Input;
    using UnityEngine.XR.WSA.WebCam;

  4. Do třídy ImageCapture přidejte následující proměnné:

        /// <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. Přidejte metody Awake() a Start(), které jsou nezbytné k inicializaci třídy a umožňují HoloLens zachytit gesta uživatele:

        /// <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. Přidejte TapHandler(), která se volá, když uživatel provede gesto klepnutí:

        /// <summary>
    /// Respond to Tap Input.
    /// </summary>
    private void TapHandler(TappedEventArgs obj)
    {
        tapsCount++;
        ExecuteImageCaptureAndAnalysis();
    }

  7. Přidejte metodu ExecuteImageCaptureAndAnalysis(), která zahájí proces zachytávání obrázků:

        /// <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. Přidejte obslužné rutiny, které se volají při dokončení procesu pořizování fotek:

        /// <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ž se vrátíte do Unity Editoru, nezapomeňte změny uložit .

Kapitola 8 – Sestavení řešení

Pokud chcete provést důkladný test aplikace, budete ji muset načíst na HoloLens bokem.

Než to uděláte, ujistěte se, že:

  • Všechna nastavení uvedená v kapitole 3 jsou správně nastavena.
  • Skript FaceAnalysis je připojen k objektu Hlavní kamera.
  • V rámci skriptu FaceAnalysis je nastavený ověřovací klíč i ID skupiny.

Tento bod je připravený k sestavení řešení. Po sestavení řešení budete připraveni nasadit aplikaci.

Zahájení procesu sestavení:

  1. Aktuální scénu uložte kliknutím na Soubor, Uložit.

  2. Přejděte na Soubor, Nastavení sestavení a klikněte na Přidat otevřené scény.

  3. Nezapomeňte zaškrtnout projekty Unity C#.

    Nasazení řešení sady Visual Studio

  4. Stiskněte build. Po tom Unity spustí okno Průzkumník souborů, ve kterém potřebujete vytvořit a vybrat složku, do které se aplikace sestaví. Vytvořte ji teď v rámci projektu Unity a pojmenujte ji Aplikace. Pak s vybranou složkou Aplikace stiskněte vybrat složku.

  5. Unity začne sestavovat váš projekt mimo složku Aplikace.

  6. Jakmile Unity dokončí sestavování (může to nějakou dobu trvat), otevře se okno Průzkumník souborů na místě sestavení.

    Nasazení řešení ze sady Visual Studio

  7. Otevřete složku Aplikace a otevřete nové řešení projektu (jak vidíte výše MR_FaceRecognition.sln).

Kapitola 9 – Nasazení aplikace

Nasazení na HoloLens:

  1. Budete potřebovat IP adresu vašeho HoloLensu (pro vzdálené nasazení) a zajistit, aby byl HoloLens v režimu vývojáře. Akce:

    1. Když nosíte HoloLens, otevřete Nastavení.
    2. Přejít na možnosti Rozšířené možnosti sítě a internetu > Wi-Fi >
    3. Poznamenejte si adresu IPv4 .
    4. Pak přejděte zpět na Nastavení a pak přejděte na Aktualizovat a zabezpečení > pro vývojáře.
    5. Nastavte režim vývojáře.

  2. Přejděte do nového sestavení Unity ( složka aplikace ) a otevřete soubor řešení v sadě Visual Studio.

  3. V konfiguraci řešení vyberte Ladit.

  4. Na platformě řešení vyberte x86, Vzdálený počítač.

    Změna konfigurace řešení

  5. Přejděte do nabídky Sestavení a kliknutím na Nasadit řešení načtěte aplikaci do holoLensu bokem.

  6. Vaše aplikace by se teď měla zobrazit v seznamu nainstalovaných aplikací na vašem HoloLensu, připravených ke spuštění!

Poznámka:

Pokud chcete nasadit do imerzivní náhlavní soupravy, nastavte platformu řešení na místní počítač a nastavte konfiguraci na Ladění s platformou x86. Potom nasaďte na místní počítač pomocí nabídky Sestavení a vyberte Nasadit řešení.

Kapitola 10 – Použití aplikace

  1. Na sobě HoloLens spusťte aplikaci.

  2. Podívejte se na osobu, kterou jste zaregistrovali v rozhraní API pro rozpoznávání tváře. Ujistěte se, že:

    • Tvář člověka není příliš vzdálená a jasně viditelná
    • Osvětlení prostředí není příliš tmavé.

  3. Pomocí gesta klepnutím můžete zachytit obrázek osoby.

  4. Počkejte, až aplikace odešle žádost o analýzu a přijme odpověď.

  5. Pokud se osoba úspěšně rozpoznala, jméno osoby se zobrazí jako text uživatelského rozhraní.

  6. Proces zachycení můžete opakovat pomocí gesta klepnutím každých několik sekund.

Hotová aplikace rozhraní API pro rozpoznávání tváře v Azure

Blahopřejeme, vytvořili jste aplikaci hybridní reality, která využívá službu Rozpoznávání tváře Azure k detekci tváří na obrázku a identifikaci známých tváří.

výsledek dokončení tohoto kurzu

Bonusová cvičení

Cvičení 1

Rozhraní API pro rozpoznávání tváře Azure je dostatečně výkonné, aby na jednom obrázku rozpoznalo až 64 tváří. Rozšiřte aplikaci tak, aby rozpoznala dvě nebo tři tváře, mezi mnoha dalšími lidmi.

Cvičení 2

Rozhraní API pro rozpoznávání tváře Azure také dokáže poskytovat všechny druhy informací o atributech. Integrujte ji do aplikace. To může být ještě zajímavější v kombinaci s rozhraním API pro rozpoznávání emocí.