HoloLens (1. generacji) i Azure 304: rozpoznawanie twarzy
Uwaga
Samouczki akademii rzeczywistości mieszanej zostały zaprojektowane z myślą o urządzeniach HoloLens (1. generacji) i zestawach słuchawkowych immersyjnych rzeczywistości mieszanej. W związku z tym uważamy, że ważne jest pozostawienie tych samouczków na miejscu dla deweloperów, którzy nadal szukają wskazówek dotyczących opracowywania tych urządzeń. Te samouczki nie zostaną zaktualizowane przy użyciu najnowszych zestawów narzędzi ani interakcji używanych dla urządzenia HoloLens 2. Będą one utrzymywane w celu kontynuowania pracy na obsługiwanych urządzeniach. W przyszłości zostanie opublikowana nowa seria samouczków, które pokażą, jak opracowywać urządzenia HoloLens 2. To powiadomienie zostanie zaktualizowane za pomocą linku do tych samouczków po ich opublikowaniu.
W tym kursie dowiesz się, jak dodać funkcje rozpoznawania twarzy do aplikacji rzeczywistości mieszanej przy użyciu usług Azure Cognitive Services z interfejsem API rozpoznawania twarzy firmy Microsoft.
Interfejs API rozpoznawania twarzy platformy Azure to usługa firmy Microsoft, która zapewnia deweloperom najbardziej zaawansowane algorytmy rozpoznawania twarzy— wszystkie w chmurze. Interfejs API rozpoznawania twarzy ma dwie główne funkcje: wykrywanie twarzy z atrybutami i rozpoznawanie twarzy. Dzięki temu deweloperzy mogą po prostu ustawić zestaw grup dla twarzy, a następnie wysyłać obrazy zapytań do usługi później, aby określić, do kogo należy twarz. Aby uzyskać więcej informacji, odwiedź stronę rozpoznawania twarzy platformy Azure.
Po ukończeniu tego kursu będziesz mieć aplikację HoloLens rzeczywistości mieszanej, która będzie mogła wykonać następujące czynności:
- Użyj gestu naciśnięcia, aby zainicjować przechwytywanie obrazu przy użyciu aparatu HoloLens na pokładzie.
- Wyślij przechwycony obraz do usługi interfejsu API rozpoznawania twarzy platformy Azure.
- Otrzymuj wyniki algorytmu interfejsu API rozpoznawania twarzy.
- Użyj prostego interfejsu użytkownika, aby wyświetlić nazwę dopasowanych osób.
Dzięki temu dowiesz się, jak uzyskać wyniki z usługi interfejsu API rozpoznawania twarzy w aplikacji rzeczywistości mieszanej opartej na środowisku Unity.
W aplikacji należy do Ciebie, jak zintegrować wyniki z projektem. Ten kurs został zaprojektowany, aby nauczyć cię, jak zintegrować usługę platformy Azure z projektem aparatu Unity. Twoim zadaniem jest wykorzystanie wiedzy uzyskanych z tego kursu w celu ulepszenia aplikacji rzeczywistości mieszanej.
Obsługa urządzeń
| Kurs | HoloLens | Immersyjne zestawy nagłowne |
|---|---|---|
| MR i Azure 304: rozpoznawanie twarzy | ✔️ | ✔️ |
Uwaga
Chociaż ten kurs koncentruje się głównie na urządzeniu HoloLens, możesz również zastosować to, czego nauczysz się w tym kursie, do zestawów słuchawkowych immersywnych (VR) systemu Windows Mixed Reality. Ponieważ immersyjne zestawy nagłowne (VR) nie mają dostępnych kamer, potrzebny jest zewnętrzny aparat podłączony do komputera. Wraz z kursem zobaczysz notatki dotyczące wszelkich zmian, które mogą być potrzebne do obsługi immersywnych zestawów słuchawkowych (VR).
Wymagania wstępne
Uwaga
Ten samouczek jest przeznaczony dla deweloperów, którzy mają podstawowe doświadczenie w językach Unity i C#. Należy również pamiętać, że wymagania wstępne i pisemne instrukcje zawarte w tym dokumencie reprezentują to, co zostało przetestowane i zweryfikowane w momencie pisania (maj 2018 r.). Możesz bezpłatnie korzystać z najnowszego oprogramowania, jak wymieniono w artykule dotyczącym instalacji narzędzi , choć nie należy zakładać, że informacje zawarte w tym kursie doskonale pasują do tego, co znajdziesz w nowszym oprogramowaniu niż wymienione poniżej.
Na potrzeby tego kursu zalecamy następujące oprogramowanie i sprzęt:
- Komputer deweloperzy zgodny z windows Mixed Reality na potrzeby programowania immersyjnego zestawu słuchawkowego (VR)
- Windows 10 Fall Creators Update (lub nowszy) z włączonym trybem dewelopera
- Najnowszy zestaw SDK systemu Windows 10
- Unity 2017.4
- Visual Studio 2017
- Zestaw słuchawkowy windows Mixed Reality immersywny (VR) lub Microsoft HoloLens z włączonym trybem dewelopera
- Kamera podłączona do komputera (w celu programowania immersyjnego zestawu słuchawkowego)
- Dostęp do Internetu na potrzeby instalacji platformy Azure i pobierania interfejsu API rozpoznawania twarzy
Przed rozpoczęciem
- Aby uniknąć problemów podczas tworzenia tego projektu, zdecydowanie zaleca się utworzenie projektu wymienionego w tym samouczku w folderze głównym lub niemal głównym (długie ścieżki folderów mogą powodować problemy w czasie kompilacji).
- Skonfiguruj i przetestuj urządzenie HoloLens. Jeśli potrzebujesz pomocy technicznej dotyczącej konfigurowania urządzenia HoloLens, zapoznaj się z artykułem dotyczącym konfiguracji urządzenia HoloLens.
- Dobrym pomysłem jest przeprowadzenie kalibracji i dostrajania czujników podczas tworzenia nowej aplikacji HoloLens (czasami może to pomóc w wykonywaniu tych zadań dla każdego użytkownika).
Aby uzyskać pomoc dotyczącą kalibracji, skorzystaj z tego linku do artykułu Kalibracja urządzenia HoloLens.
Aby uzyskać pomoc dotyczącą dostrajania czujników, skorzystaj z tego linku do artykułu Dostrajanie czujników HoloLens.
Rozdział 1 — Witryna Azure Portal
Aby korzystać z usługi interfejsu API rozpoznawania twarzy na platformie Azure, należy skonfigurować wystąpienie usługi, które ma zostać udostępnione aplikacji.
Najpierw zaloguj się do witryny Azure Portal.
Uwaga
Jeśli nie masz jeszcze konta platformy Azure, musisz je utworzyć. Jeśli obserwujesz ten samouczek w sytuacji w klasie lub laboratorium, poproś instruktora lub jednego z opiekunów o pomoc przy konfigurowaniu nowego konta.
Po zalogowaniu kliknij pozycję Nowy w lewym górnym rogu i wyszukaj pozycję Interfejs API rozpoznawania twarzy, naciśnij Enter.
Uwaga
Wyraz Nowy mógł zostać zastąpiony ciągiem Create a resource (Utwórz zasób) w nowszych portalach.
Nowa strona zawiera opis usługi interfejsu API rozpoznawania twarzy. W lewym dolnym rogu tego monitu wybierz przycisk Utwórz , aby utworzyć skojarzenie z tą usługą.
Po kliknięciu pozycji Utwórz:
Wstaw żądaną nazwę dla tego wystąpienia usługi.
Wybierz subskrypcję.
Wybierz odpowiednią warstwę cenową, jeśli jest to pierwszy raz podczas tworzenia usługi interfejsu API rozpoznawania twarzy, warstwa bezpłatna (o nazwie F0) powinna być dostępna dla Ciebie.
Wybierz grupę zasobów lub utwórz nową. Grupa zasobów umożliwia monitorowanie, kontrolowanie dostępu, aprowizowania i zarządzania rozliczeniami dla kolekcji zasobów platformy Azure. Zaleca się zachowanie wszystkich usług platformy Azure skojarzonych z jednym projektem (np. takich jak te laboratoria) w ramach wspólnej grupy zasobów.
Jeśli chcesz dowiedzieć się więcej na temat grup zasobów platformy Azure, odwiedź artykuł grupy zasobów.
Aplikacja platformy UNIWERSALNEJ systemu Windows, Person Maker, której używasz później, wymaga użycia elementu "Zachodnie stany USA" dla lokalizacji.
Musisz również potwierdzić, że rozumiesz warunki i postanowienia zastosowane do tej usługi.
Wybierz pozycję Utwórz.*
Po kliknięciu pozycji Utwórz* trzeba będzie poczekać na utworzenie usługi. Może to potrwać minutę.
Po utworzeniu wystąpienia usługi w portalu zostanie wyświetlone powiadomienie.
Kliknij powiadomienia, aby zapoznać się z nowym wystąpieniem usługi.
Gdy wszystko będzie gotowe, kliknij przycisk Przejdź do zasobu w powiadomieniu, aby eksplorować nowe wystąpienie usługi.
W ramach tego samouczka aplikacja będzie musiała wykonywać wywołania usługi, co odbywa się za pomocą subskrypcji usługi "klucz". Na stronie Szybki start usługi interfejsu API rozpoznawania twarzy pierwszy punkt to numer 1, aby pobrać klucze.
Na stronie Usługa wybierz niebieski hiperlink Klucze (jeśli na stronie Szybki start) lub link Klucze w menu nawigacji usług (po lewej stronie, oznaczony ikoną "klucz"), aby wyświetlić klucze.
Uwaga
Zanotuj jeden z kluczy i zabezpieczeń go, ponieważ będzie potrzebny później.
Rozdział 2 — Korzystanie z aplikacji platformy UWP "Person Maker"
Pamiętaj, aby pobrać wstępnie utworzoną aplikację platformy UWP o nazwie Person Maker. Ta aplikacja nie jest produktem końcowym dla tego kursu, tylko narzędziem, które ułatwia tworzenie wpisów platformy Azure, na których będzie polegać późniejszy projekt.
Usługa Person Maker umożliwia tworzenie wpisów platformy Azure, które są skojarzone z osobami i grupami osób. Aplikacja będzie umieszczać wszystkie potrzebne informacje w formacie, który następnie może być używany przez interfejs FaceAPI w celu rozpoznawania twarzy osób, które zostały dodane.
[WAŻNE] Usługa Person Maker używa niektórych podstawowych ograniczeń, aby zapewnić, że liczba wywołań usługi na minutę nie przekracza warstwy subskrypcji bezpłatnej. Zielony tekst u góry zmieni się na czerwony i zaktualizuje wartość "ACTIVE" podczas ograniczania przepustowości; Jeśli tak jest, po prostu zaczekaj na aplikację (będzie czekać, aż będzie mogła kontynuować dostęp do usługi rozpoznawania twarzy, aktualizując ją jako "IN-ACTIVE", gdy będzie można jej ponownie użyć).
Ta aplikacja używa bibliotek Microsoft.ProjectOxford.Face , które umożliwiają pełne korzystanie z interfejsu API rozpoznawania twarzy. Ta biblioteka jest bezpłatna dostępna jako pakiet NuGet. Aby uzyskać więcej informacji na temat tego i podobnych interfejsów API, zapoznaj się z artykułem Dokumentacja interfejsu API.
Uwaga
Są to tylko wymagane kroki, instrukcje dotyczące wykonywania tych czynności są bardziej szczegółowe w dokumencie. Aplikacja Person Maker umożliwia wykonywanie następujących czynności:
Utwórz grupę osób, która jest grupą składającą się z kilku osób, które chcesz z nią skojarzyć. Za pomocą konta platformy Azure możesz hostować wiele grup osób.
Utwórz osobę, która jest członkiem grupy osób. Każda osoba ma wiele skojarzonych obrazów twarzy .
Przypisz obrazy twarzy do osoby, aby umożliwić usłudze interfejsu API rozpoznawania twarzy platformy Azure rozpoznawanie osoby przy użyciu odpowiedniej twarzy.
Trenowanie usługi interfejsu API rozpoznawania twarzy platformy Azure.
Pamiętaj, aby wytrenować tę aplikację do rozpoznawania osób, musisz mieć dziesięć (10) zdjęć zbliżeniowych każdej osoby, którą chcesz dodać do grupy osób. Aplikacja cam systemu Windows 10 może pomóc w ich podjęciu. Należy upewnić się, że każde zdjęcie jest jasne (unikać rozmycia, zaciemniania lub zbyt daleko od tematu), mieć zdjęcie w formacie jpg lub png, z rozmiarem pliku obrazu nie większym 4 MB, a nie mniejszym niż 1 KB.
Uwaga
Jeśli wykonasz czynności opisane w tym samouczku, nie używaj własnej twarzy do trenowania, ponieważ po włączeniu urządzenia HoloLens nie możesz spojrzeć na siebie. Użyj twarzy kolegi lub kolegi studenta.
Uruchamianie twórcy osób:
Otwórz folder PersonMaker i kliknij dwukrotnie rozwiązanie PersonMaker, aby otworzyć je za pomocą programu Visual Studio.
Po otwarciu rozwiązania PersonMaker upewnij się, że:
Konfiguracja rozwiązania jest ustawiona na Debugowanie.
Platforma rozwiązania jest ustawiona na x86
Platforma docelowa to maszyna lokalna.
Może być również konieczne przywrócenie pakietów NuGet (kliknij prawym przyciskiem myszy rozwiązanie i wybierz polecenie Przywróć pakiety NuGet).
Kliknij pozycję Komputer lokalny, a aplikacja zostanie uruchomiona. Należy pamiętać, że na mniejszych ekranach cała zawartość może nie być widoczna, ale możesz przewinąć w dół, aby ją wyświetlić.
Wstaw klucz uwierzytelniania platformy Azure, który powinien znajdować się w usłudze interfejsu API rozpoznawania twarzy na platformie Azure.
Wstawianie:
- Identyfikator, który chcesz przypisać do grupy osób. Identyfikator musi być małymi literami bez spacji. Zanotuj ten identyfikator, ponieważ będzie on wymagany później w projekcie aparatu Unity.
- Nazwa, którą chcesz przypisać do grupy osób (może mieć spacje).
Naciśnij przycisk Utwórz grupę osób. Pod przyciskiem powinien pojawić się komunikat potwierdzający.
Uwaga
Jeśli wystąpił błąd "Odmowa dostępu", sprawdź lokalizację ustawioną dla usługi platformy Azure. Jak wspomniano powyżej, ta aplikacja jest przeznaczona dla "Zachodnie stany USA".
Ważne
Zauważysz, że możesz również kliknąć przycisk Pobierz znaną grupę: jeśli grupa osób została już utworzona i chcesz jej użyć, zamiast utworzyć nową grupę. Pamiętaj, że jeśli klikniesz pozycję Utwórz grupę osób ze znaną grupą, spowoduje to również pobranie grupy.
Wstaw imię i nazwisko osoby, którą chcesz utworzyć.
Kliknij przycisk Utwórz osobę.
Pod przyciskiem powinien pojawić się komunikat potwierdzający.
Jeśli chcesz usunąć wcześniej utworzoną osobę, możesz napisać nazwę w polu tekstowym i nacisnąć Delete Person
Upewnij się, że znasz lokalizację dziesięciu (10) zdjęć osoby, którą chcesz dodać do grupy.
Naciśnij pozycję Utwórz i Otwórz folder , aby otworzyć Eksploratora Windows w folderze skojarzonym z osobą. Dodaj dziesięć (10) obrazów w folderze. Muszą być w formacie JPG lub PNG .
Kliknij pozycję Prześlij do platformy Azure. Licznik wyświetli stan przesyłania, po którym następuje komunikat po zakończeniu.
Po zakończeniu licznika i wyświetleniu komunikatu z potwierdzeniem kliknij pozycję Trenuj , aby wytrenować usługę.
Po zakończeniu procesu możesz przejść do środowiska Unity.
Rozdział 3 . Konfigurowanie projektu aparatu Unity
Poniżej przedstawiono typową konfigurację do opracowywania za pomocą rzeczywistości mieszanej, a w związku z tym jest to dobry szablon dla innych projektów.
Otwórz aparat Unity i kliknij pozycję Nowy.
Teraz musisz podać nazwę projektu aparatu Unity. Wstaw MR_FaceRecognition. Upewnij się, że typ projektu jest ustawiony na wartość 3D. Ustaw lokalizację na odpowiednią dla Ciebie (pamiętaj, że bliżej katalogów głównych jest lepiej). Następnie kliknij pozycję Utwórz projekt.
Po otwarciu aparatu Unity warto sprawdzić, czy domyślny edytor skryptów jest ustawiony na program Visual Studio. Przejdź do pozycji Edytuj > preferencje , a następnie w nowym oknie przejdź do pozycji Narzędzia zewnętrzne. Zmień edytor skryptów zewnętrznych na Visual Studio 2017. Zamknij okno Preferencje.
Następnie przejdź do pozycji Ustawienia kompilacji plików > i przełącz platformę na platforma uniwersalna systemu Windows, klikając przycisk Przełącz platformę.
Przejdź do pozycji Ustawienia kompilacji pliku > i upewnij się, że:
Urządzenie docelowe jest ustawione na urządzenie HoloLens
W przypadku immersyjnych zestawów słuchawkowych ustaw opcję Urządzenie docelowe na dowolne urządzenie.
Typ kompilacji jest ustawiony na D3D
Zestaw SDK jest ustawiony na najnowszą zainstalowaną
Dla wersji programu Visual Studio jest ustawiona wartość Najnowsza zainstalowana
Kompilowanie i uruchamianie jest ustawione na komputer lokalny
Zapisz scenę i dodaj ją do kompilacji.
W tym celu wybierz pozycję Dodaj otwarte sceny. Zostanie wyświetlone okno zapisywania.
Wybierz przycisk Nowy folder, aby utworzyć nowy folder, nadaj mu nazwę Sceny.
Otwórz nowo utworzony folder Sceny , a następnie w polu Nazwa pliku: tekst wpisz FaceRecScene, a następnie naciśnij przycisk Zapisz.
Pozostałe ustawienia w obszarze Ustawienia kompilacji powinny być pozostawione jako domyślne na razie.
W oknie Ustawienia kompilacji kliknij przycisk Ustawienia odtwarzacza, spowoduje to otwarcie powiązanego panelu w obszarze, w którym znajduje się inspektor.
W tym panelu należy zweryfikować kilka ustawień:
Na karcie Inne ustawienia:
Wersja środowiska uruchomieniowego skryptów powinna być eksperymentalna (odpowiednik platformy.NET 4.6). Zmiana tej zmiany spowoduje konieczność ponownego uruchomienia edytora.
Zaplecze skryptów powinno mieć wartość .NET
Poziom zgodności interfejsu API powinien mieć wartość .NET 4.6
Na karcie Ustawienia publikowania w obszarze Możliwości sprawdź:
InternetClient
Kamera internetowa
W dalszej części panelu w obszarze Ustawienia XR (znajdujące się poniżej ustawienia publikowania) zaznacz pole Virtual Reality Supported (Obsługiwane w rzeczywistości wirtualnej), upewnij się, że dodano zestaw WINDOWS Mixed Reality SDK .
Po powrocie do ustawień kompilacji projekty języka C# aparatu Unity nie są już wyszarzone; zaznacz pole wyboru obok tego.
Zamknij okno Build Settings (Ustawienia kompilacji).
Zapisz scenę i projekt (PLIK > ZAPISZ SCENĘ / PLIK > ZAPISZ PROJEKT).
Rozdział 4 — Konfiguracja kamery głównej
Ważne
Jeśli chcesz pominąć składnik Konfiguracji aparatu Unity tego kursu i kontynuować bezpośrednio w kodzie, możesz pobrać ten pakiet unitypackage i zaimportować go do projektu jako pakiet niestandardowy. Należy pamiętać, że ten pakiet zawiera również import biblioteki DLL Newtonsoft, omówionej w rozdziale 5. Po zaimportowaniu możesz kontynuować pracę z rozdziału 6.
W panelu hierarchii wybierz kamerę główną.
Po wybraniu tej opcji będzie można zobaczyć wszystkie składniki głównego aparatu w Panelu inspektora.
Obiekt Aparatu musi mieć nazwę Main Camera (zanotuj pisownię!)
Główny tag aparatu musi być ustawiony na MainCamera (zanotuj pisownię!)
Upewnij się, że pozycja przekształcania jest ustawiona na 0, 0, 0
Ustaw przezroczyste flagi na kolor stały
Ustaw kolor tła składnika aparatu na , Alfa 0 (kod szesnastkowy: #00000000)
Rozdział 5 — importowanie biblioteki Newtonsoft.Json
Ważne
Jeśli zaimportowaliśmy pakiet ".unitypackage" w ostatnim rozdziale, możesz pominąć ten rozdział.
Aby ułatwić deserializacji i serializowania odebranych i wysłanych do usługi Bot Service, należy pobrać bibliotekę Newtonsoft.Json . W tym pliku pakietu aparatu Unity znajdziesz już zgodną wersję zorganizowaną z poprawną strukturą folderów aparatu Unity.
Aby zaimportować bibliotekę:
Pobierz pakiet aparatu Unity.
Kliknij pozycję Zasoby, Importuj pakiet, Pakiet niestandardowy.
Wyszukaj pobrany pakiet aparatu Unity, a następnie kliknij przycisk Otwórz.
Upewnij się, że wszystkie składniki pakietu są zaznaczone, a następnie kliknij przycisk Importuj.
Rozdział 6 . Tworzenie klasy FaceAnalysis
Celem klasy FaceAnalysis jest hostowanie metod niezbędnych do komunikowania się z usługą rozpoznawania twarzy platformy Azure.
- Po wysłaniu usługi obrazu przechwytywania przeanalizuje go i zidentyfikuje twarze w obrębie i określi, czy należą one do znanej osoby.
- Jeśli zostanie znaleziona znana osoba, ta klasa wyświetli swoją nazwę jako tekst interfejsu użytkownika w scenie.
Aby utworzyć klasę FaceAnalysis :
Kliknij prawym przyciskiem myszy folder Assets znajdujący się w panelu projektu, a następnie kliknij polecenie Utwórz>folder. Wywołaj folder Scripts.
Kliknij dwukrotnie właśnie utworzony folder, aby go otworzyć.
Kliknij prawym przyciskiem myszy wewnątrz folderu, a następnie kliknij polecenie Utwórz>skrypt języka C#. Wywołaj skrypt FaceAnalysis.
Kliknij dwukrotnie nowy skrypt FaceAnalysis , aby otworzyć go za pomocą programu Visual Studio 2017.
Wprowadź następujące przestrzenie nazw powyżej klasy FaceAnalysis :
using Newtonsoft.Json; using System.Collections; using System.Collections.Generic; using System.IO; using System.Text; using UnityEngine; using UnityEngine.Networking;Teraz należy dodać wszystkie obiekty, które są używane do deserializacji. Te obiekty należy dodać poza skryptem FaceAnalysis (poniżej dolnego nawiasu klamrowego).
/// <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; } }Metody Start() i Update() nie będą używane, więc usuń je teraz.
Wewnątrz klasy FaceAnalysis dodaj następujące zmienne:
/// <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 -";Uwaga
Zastąp klucz i personGroupId kluczem usługi oraz identyfikatorem utworzonej wcześniej grupy.
Dodaj metodę Awake(), która inicjuje klasę, dodając klasę ImageCapture do aparatu głównego i wywołuje metodę tworzenia etykiety:
/// <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(); }Dodaj metodę CreateLabel(), która tworzy obiekt Label w celu wyświetlenia wyniku analizy:
/// <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 = "."; }Dodaj metodę DetectFacesFromImage() i GetImageAsByteArray(). Pierwsza z nich zażąda usługi rozpoznawania twarzy w celu wykrycia dowolnej możliwej twarzy na przesłanym obrazie, podczas gdy ten ostatni jest niezbędny do przekonwertowania przechwyconego obrazu na tablicę bajtów:
/// <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); }Dodaj metodę IdentifyFaces(), która żąda usługi rozpoznawania twarzy, aby zidentyfikować wszystkie znane twarze wykryte wcześniej na przesłanym obrazie. Żądanie zwróci identyfikator zidentyfikowanej osoby, ale nie nazwę:
/// <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); } } }Dodaj metodę GetPerson(). Podając identyfikator osoby, ta metoda żąda, aby usługa rozpoznawania twarzy zwróciła nazwę zidentyfikowanej 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; } }Pamiętaj, aby zapisać zmiany przed powrotem do edytora aparatu Unity.
W Edytorze aparatu Unity przeciągnij skrypt FaceAnalysis z folderu Scripts (Skrypty) na panel Project (Skrypty) do obiektu Main Camera (Aparat główny) na panelu Hierarchy (Hierarchia). Nowy składnik skryptu zostanie więc dodany do aparatu głównego.
Rozdział 7 . Tworzenie klasy ImageCapture
Celem klasy ImageCapture jest hostowanie metod niezbędnych do komunikowania się z usługą rozpoznawania twarzy platformy Azure w celu przeanalizowania przechwyconego obrazu, identyfikowania w nim twarzy i określania, czy należy do znanej osoby. Jeśli zostanie znaleziona znana osoba, ta klasa wyświetli swoją nazwę jako tekst interfejsu użytkownika w scenie.
Aby utworzyć klasę ImageCapture :
Kliknij prawym przyciskiem myszy wewnątrz utworzonego wcześniej folderu Skrypty , a następnie kliknij pozycję Utwórz, skrypt języka C#. Wywołaj skrypt ImageCapture.
Kliknij dwukrotnie nowy skrypt ImageCapture , aby otworzyć go za pomocą programu Visual Studio 2017.
Wprowadź następujące przestrzenie nazw powyżej klasy ImageCapture:
using System.IO; using System.Linq; using UnityEngine; using UnityEngine.XR.WSA.Input; using UnityEngine.XR.WSA.WebCam;Wewnątrz klasy ImageCapture dodaj następujące zmienne:
/// <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;Dodaj metody Awake() i Start() niezbędne do zainicjowania klasy i umożliwiają urządzeniu HoloLens przechwytywanie gestów użytkownika:
/// <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(); }Dodaj funkcję TapHandler(), która jest wywoływana, gdy użytkownik wykonuje gest Naciśnięcie:
/// <summary> /// Respond to Tap Input. /// </summary> private void TapHandler(TappedEventArgs obj) { tapsCount++; ExecuteImageCaptureAndAnalysis(); }Dodaj metodę ExecuteImageCaptureAndAnalysis(), która rozpocznie proces przechwytywania obrazów:
/// <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); }); }); }Dodaj programy obsługi, które są wywoływane po zakończeniu procesu przechwytywania zdjęć:
/// <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()); }Pamiętaj, aby zapisać zmiany przed powrotem do edytora aparatu Unity.
Rozdział 8 — Tworzenie rozwiązania
Aby przeprowadzić dokładny test aplikacji, należy załadować ją bezpośrednio na urządzenie HoloLens.
Przed wykonaniem upewnij się, że:
- Wszystkie ustawienia wymienione w rozdziale 3 są ustawione poprawnie.
- Skrypt FaceAnalysis jest dołączony do obiektu Main Camera.
- Zarówno klucz uwierzytelniania, jak i identyfikator grupy zostały ustawione w skryscie FaceAnalysis.
Ten punkt jest gotowy do utworzenia rozwiązania. Po utworzeniu rozwiązania będzie można przystąpić do wdrażania aplikacji.
Aby rozpocząć proces kompilacji:
Zapisz bieżącą scenę, klikając pozycję Plik, Zapisz.
Przejdź do pozycji Plik, Ustawienia kompilacji, kliknij pozycję Dodaj otwarte sceny.
Pamiętaj, aby zaznaczyć pozycje Projekty języka C# aparatu Unity.
Naciśnij pozycję Build (Kompilacja). W tym celu aparat Unity uruchomi okno Eksplorator plików, w którym należy utworzyć, a następnie wybierz folder, w którym zostanie skompilowanie aplikacji. Utwórz ten folder teraz w projekcie aparatu Unity i wywołaj go aplikację. Następnie po wybraniu folderu App naciśnij pozycję Wybierz folder.
Aparat Unity rozpocznie kompilowanie projektu w folderze App.
Po zakończeniu kompilowania aparatu Unity (może to trochę potrwać), zostanie otwarte okno Eksplorator plików w lokalizacji kompilacji.
Otwórz folder Aplikacja, a następnie otwórz nowe rozwiązanie projektu (jak pokazano powyżej, MR_FaceRecognition.sln).
Rozdział 9 — Wdrażanie aplikacji
Aby wdrożyć na urządzeniu HoloLens:
Będziesz potrzebować adresu IP urządzenia HoloLens (na potrzeby zdalnego wdrażania) i upewnij się, że urządzenie HoloLens jest w trybie dewelopera. Czynność:
- Podczas noszenia urządzenia HoloLens otwórz ustawienia.
- Przejdź do pozycji Sieć i Internetowe > opcje zaawansowane sieci Wi-Fi >
- Zanotuj adres IPv4 .
- Następnie przejdź z powrotem do pozycji Ustawienia, a następnie przejdź do pozycji Aktualizuj i zabezpieczenia > dla deweloperów
- Ustaw tryb dewelopera wł.
Przejdź do nowej kompilacji aparatu Unity ( folderu App ) i otwórz plik rozwiązania za pomocą programu Visual Studio.
W obszarze Konfiguracja rozwiązania wybierz pozycję Debuguj.
W polu Platforma rozwiązania wybierz pozycję x86, Maszyna zdalna.
Przejdź do menu Kompilacja i kliknij pozycję Wdróż rozwiązanie, aby załadować aplikację bezpośrednio do urządzenia HoloLens.
Aplikacja powinna teraz zostać wyświetlona na liście zainstalowanych aplikacji na urządzeniu HoloLens, które będą gotowe do uruchomienia.
Uwaga
Aby wdrożyć w immersywnym zestawie słuchawkowym, ustaw wartość Platforma rozwiązania na Komputer lokalny i ustaw wartość Konfiguracja na Debugowanie z wartością x86 jako platforma. Następnie wdróż na komputerze lokalnym, korzystając z menu Kompilacja, wybierając pozycję Wdróż rozwiązanie.
Rozdział 10 — Korzystanie z aplikacji
Na urządzeniu HoloLens uruchom aplikację.
Przyjrzyj się osobie zarejestrowanej w interfejsie API rozpoznawania twarzy. Upewnij się, że:
- Twarz osoby nie jest zbyt daleka i wyraźnie widoczna
- Oświetlenie środowiska nie jest zbyt ciemne
Użyj gestu naciśnięcia, aby uchwycić obraz osoby.
Poczekaj, aż aplikacja wyśle żądanie analizy i otrzyma odpowiedź.
Jeśli dana osoba została pomyślnie rozpoznana, imię osoby będzie wyświetlane jako tekst interfejsu użytkownika.
Proces przechwytywania można powtórzyć za pomocą gestu naciśnięcia co kilka sekund.
Zakończona aplikacja interfejsu API rozpoznawania twarzy platformy Azure
Gratulacje, utworzono aplikację rzeczywistości mieszanej, która wykorzystuje usługę rozpoznawania twarzy platformy Azure do wykrywania twarzy na obrazie i identyfikowania znanych twarzy.
Ćwiczenia dodatkowe
Ćwiczenie 1
Interfejs API rozpoznawania twarzy platformy Azure jest wystarczająco zaawansowany, aby wykryć maksymalnie 64 twarze na jednym obrazie. Rozszerz aplikację, aby mogła rozpoznać dwie lub trzy twarze między wieloma innymi osobami.
Ćwiczenie 2
Interfejs API rozpoznawania twarzy platformy Azure może również udostępniać wszelkiego rodzaju informacje o atrybutach. Zintegruj to z aplikacją. Może to być jeszcze bardziej interesujące w połączeniu z interfejsem API rozpoznawania emocji.