Réalité mixte - Azure - Cours 304 : Reconnaissance facialeMR and Azure 304: Face recognition


Notes

Les tutoriels Mixed Reality Academy ont été conçus pour les appareils HoloLens (1re génération) et les casques immersifs de réalité mixte.The Mixed Reality Academy tutorials were designed with HoloLens (1st gen) and Mixed Reality Immersive Headsets in mind. Nous estimons qu’il est important de laisser ces tutoriels à la disposition des développeurs qui recherchent encore des conseils pour développer des applications sur ces appareils.As such, we feel it is important to leave these tutorials in place for developers who are still looking for guidance in developing for those devices. Notez que ces tutoriels ne sont pas mis à jour avec les derniers ensembles d’outils ou interactions utilisés pour HoloLens 2.These tutorials will not be updated with the latest toolsets or interactions being used for HoloLens 2. Ils sont fournis dans le but de fonctionner sur les appareils pris en charge.They will be maintained to continue working on the supported devices. Une nouvelle série de didacticiels sera publiée à l’avenir qui vous montrera comment développer pour HoloLens 2.There will be a new series of tutorials that will be posted in the future that will demonstrate how to develop for HoloLens 2. Cet avis sera mis à jour avec un lien vers ces didacticiels lors de leur publication.This notice will be updated with a link to those tutorials when they are posted.


résultat de la fin de ce cours

Dans ce cours, vous allez apprendre à ajouter des fonctionnalités de reconnaissance faciale à une application de réalité mixte, à l’aide d’Azure Cognitive Services, avec la API Visage Microsoft.In this course you will learn how to add face recognition capabilities to a mixed reality application, using Azure Cognitive Services, with the Microsoft Face API.

Azure API visage est un service Microsoft qui fournit aux développeurs les algorithmes les plus avancés, le tout dans le Cloud.Azure Face API is a Microsoft service, which provides developers with the most advanced face algorithms, all in the cloud. La API visage a deux fonctions principales : la détection des visages avec les attributs et la reconnaissance faciale.The Face API has two main functions: face detection with attributes, and face recognition. Cela permet aux développeurs de définir simplement un ensemble de groupes pour les visages, puis d’envoyer des images de requête au service ultérieurement, pour déterminer à qui appartient une face.This allows developers to simply set a set of groups for faces, and then, send query images to the service later, to determine to whom a face belongs. Pour plus d’informations, consultez la page reconnaissance des visages Azure.For more information, visit the Azure Face Recognition page.

Une fois ce cours terminé, vous disposerez d’une application HoloLens de réalité mixte, qui sera en mesure d’effectuer les opérations suivantes :Having completed this course, you will have a mixed reality HoloLens application, which will be able to do the following:

  1. Utilisez un mouvement TAP pour initier la capture d’une image à l’aide de l’appareil photo HoloLens intégré.Use a Tap Gesture to initiate the capture of an image using the on-board HoloLens camera.
  2. Envoyez l’image capturée au service Azure API visage .Send the captured image to the Azure Face API service.
  3. Recevoir les résultats de l’algorithme API visage .Receive the results of the Face API algorithm.
  4. Utilisez une interface utilisateur simple pour afficher le nom des personnes mises en correspondance.Use a simple User Interface, to display the name of matched people.

Cela vous apprend à obtenir les résultats du service API Visage dans votre application de réalité mixte basée sur Unity.This will teach you how to get the results from the Face API Service into your Unity-based mixed reality application.

Dans votre application, c’est à vous de savoir comment vous allez intégrer les résultats à votre conception.In your application, it is up to you as to how you will integrate the results with your design. Ce cours est conçu pour vous apprendre à intégrer un service Azure à votre projet Unity.This course is designed to teach you how to integrate an Azure Service with your Unity Project. C’est votre travail d’utiliser les connaissances que vous avez acquises dans ce cours pour améliorer votre application de réalité mixte.It is your job to use the knowledge you gain from this course to enhance your mixed reality application.

Prise en charge des appareilsDevice support

CoursCourse HoloLensHoloLens Casques immersifsImmersive headsets
Réalité mixte - Azure - Cours 304 : Reconnaissance facialeMR and Azure 304: Face recognition ✔️✔️ ✔️✔️

Notes

Bien que ce cours se concentre principalement sur HoloLens, vous pouvez également appliquer ce que vous allez apprendre dans ce cours à des casques pour Windows Mixed Reality (VR).While this course primarily focuses on HoloLens, you can also apply what you learn in this course to Windows Mixed Reality immersive (VR) headsets. Étant donné que les casques immersifs ne disposent pas de caméras accessibles, vous aurez besoin d’une caméra externe connectée à votre PC.Because immersive (VR) headsets do not have accessible cameras, you will need an external camera connected to your PC. À mesure que vous suivez le cours, vous verrez des remarques sur les modifications que vous devrez peut-être utiliser pour prendre en charge les écouteurs immersifs (VR).As you follow along with the course, you will see notes on any changes you might need to employ to support immersive (VR) headsets.

PrérequisPrerequisites

Notes

Ce didacticiel est conçu pour les développeurs qui ont une expérience de base avec Unity et C#.This tutorial is designed for developers who have basic experience with Unity and C#. Sachez également que les conditions préalables et les instructions écrites dans ce document représentent les éléments qui ont été testés et vérifiés au moment de l’écriture (mai 2018).Please also be aware that the prerequisites and written instructions within this document represent what has been tested and verified at the time of writing (May 2018). Vous êtes libre d’utiliser le logiciel le plus récent, tel qu’indiqué dans l’article installer les outils , bien qu’il ne soit pas supposé que les informations de ce cours correspondent parfaitement à ce que vous trouverez dans les logiciels plus récents que ceux répertoriés ci-dessous.You are free to use the latest software, as listed within the install the tools article, though it should not be assumed that the information in this course will perfectly match what you'll find in newer software than what's listed below.

Nous vous recommandons d’utiliser le matériel et les logiciels suivants pour ce cours :We recommend the following hardware and software for this course:

Avant de commencerBefore you start

  1. Pour éviter de rencontrer des problèmes lors de la création de ce projet, il est fortement recommandé de créer le projet mentionné dans ce didacticiel dans un dossier racine ou dans un dossier racine (les chemins de dossiers longs peuvent entraîner des problèmes au moment de la génération).To avoid encountering issues building this project, it is strongly suggested that you create the project mentioned in this tutorial in a root or near-root folder (long folder paths can cause issues at build-time).
  2. Configurez et testez votre HoloLens.Set up and test your HoloLens. Si vous avez besoin de la prise en charge de la configuration de votre HoloLens, consultez l’article Configuration de hololens.If you need support setting up your HoloLens, make sure to visit the HoloLens setup article.
  3. Il est judicieux d’effectuer un réglage de l’étalonnage et du capteur au début du développement d’une nouvelle application HoloLens (parfois, il peut être utile d’effectuer ces tâches pour chaque utilisateur).It is a good idea to perform Calibration and Sensor Tuning when beginning developing a new HoloLens App (sometimes it can help to perform those tasks for each user).

Pour obtenir de l’aide sur l’étalonnage, veuillez suivre ce lien vers l’article d’étalonnage HoloLens.For help on Calibration, please follow this link to the HoloLens Calibration article.

Pour obtenir de l’aide sur le réglage du capteur, veuillez suivre ce lien vers l’article sur le paramétrage du capteur HoloLens.For help on Sensor Tuning, please follow this link to the HoloLens Sensor Tuning article.

Chapitre 1-portail AzureChapter 1 - The Azure Portal

Pour utiliser le service de API visage dans Azure, vous devez configurer une instance du service qui sera mise à la disposition de votre application.To use the Face API service in Azure, you will need to configure an instance of the service to be made available to your application.

  1. Tout d’abord, connectez-vous au portail Azure.First, log in to the Azure Portal.

    Notes

    Si vous n’avez pas encore de compte Azure, vous devez en créer un.If you do not already have an Azure account, you will need to create one. Si vous suivez ce didacticiel dans une situation de classe ou de laboratoire, demandez à votre formateur ou à l’un des prostructors de vous aider à configurer votre nouveau compte.If you are following this tutorial in a classroom or lab situation, ask your instructor or one of the proctors for help setting up your new account.

  2. Une fois que vous êtes connecté, cliquez sur nouveau dans l’angle supérieur gauche et recherchez API visage, appuyez sur entrée.Once you are logged in, click on New in the top left corner, and search for Face API, press Enter.

    Rechercher l’API visage

    Notes

    Le mot nouveau peut avoir été remplacé par créer une ressource, dans les portails plus récents.The word New may have been replaced with Create a resource, in newer portals.

  3. La nouvelle page fournit une description du service API visage .The new page will provide a description of the Face API service. En bas à gauche de cette invite, sélectionnez le bouton créer pour créer une association avec ce service.At the bottom left of this prompt, select the Create button, to create an association with this service.

    informations sur l’API visage

  4. Une fois que vous avez cliqué sur créer:Once you have clicked on Create:

    1. Insérez le nom de votre choix pour cette instance de service.Insert your desired name for this service instance.

    2. Sélectionnez un abonnement.Select a subscription.

    3. Sélectionnez le niveau tarifaire approprié, s’il s’agit de la première fois que vous créez un Service API visage, vous devez disposer d’un niveau gratuit (nommé F0).Select the pricing tier appropriate for you, if this is the first time creating a Face API Service, a free tier (named F0) should be available to you.

    4. Choisissez un groupe de ressources ou créez-en un.Choose a Resource Group or create a new one. Un groupe de ressources permet de surveiller, de contrôler l’accès, de configurer et de gérer la facturation d’un regroupement de ressources Azure.A resource group provides a way to monitor, control access, provision and manage billing for a collection of Azure assets. Il est recommandé de conserver tous les services Azure associés à un seul projet (par exemple, ces laboratoires) sous un groupe de ressources commun).It is recommended to keep all the Azure services associated with a single project (e.g. such as these labs) under a common resource group).

      Si vous souhaitez en savoir plus sur les groupes de ressources Azure, consultez l’article du groupe de ressources.If you wish to read more about Azure Resource Groups, please visit the resource group article.

    5. L’application UWP, Person Maker, que vous utilisez ultérieurement, requiert l’utilisation de « West US » pour l’emplacement.The UWP app, Person Maker, which you use later, requires the use of 'West US' for location.

    6. Vous devrez également confirmer que vous avez compris les conditions générales appliquées à ce service.You will also need to confirm that you have understood the Terms and Conditions applied to this Service.

    7. Sélectionnez **créer *.**Select Create*.

      créer un service d’API visage

  5. Une fois que vous avez cliqué sur *créer , vous devez attendre que le service soit créé. cette opération peut prendre une minute.Once you have clicked on Create*, you will have to wait for the service to be created, this might take a minute.

  6. Une notification s’affichera dans le portail une fois l’instance de service créée.A notification will appear in the portal once the Service instance is created.

    notification de création de service

  7. Cliquez sur les notifications pour explorer votre nouvelle instance de service.Click on the notifications to explore your new Service instance.

    accéder à la notification de ressource

  8. Quand vous êtes prêt, cliquez sur le bouton atteindre la ressource dans la notification pour explorer votre nouvelle instance de service.When you are ready, click Go to resource button in the notification to explore your new Service instance.

    clés d’API de visage d’accès

  9. Dans ce didacticiel, votre application doit effectuer des appels à votre service, ce qui est effectué via l’utilisation de la « clé » de l’abonnement de votre service.Within this tutorial, your application will need to make calls to your service, which is done through using your service's subscription 'key'. Dans la page démarrage rapide de votre service API visage , le premier point est le numéro 1, pour récupérer vos clés.From the Quick start page, of your Face API service, the first point is number 1, to Grab your keys.

  10. Sur la page service , sélectionnez le lien hypertexte touches bleues (si sur la page démarrage rapide) ou le lien clés dans le menu de navigation services (à gauche, indiqué par l’icône « clé »), pour révéler vos clés.On the Service page select either the blue Keys hyperlink (if on the Quick start page), or the Keys link in the services navigation menu (to the left, denoted by the 'key' icon), to reveal your keys.

    Notes

    Prenez note de l’une des clés et protégez-la, car vous en aurez besoin plus tard.Take note of either one of the keys and safeguard it, as you will need it later.

Chapitre 2-utilisation de l’application UWP « person Maker »Chapter 2 - Using the 'Person Maker' UWP application

Veillez à télécharger l’application UWP prédéfinie appelée Person Maker.Make sure to download the prebuilt UWP Application called Person Maker. Cette application n’est pas le produit final de ce cours. il ne s’agit là que d’un outil qui vous aide à créer vos entrées Azure, sur lesquelles repose le projet ultérieur.This app is not the end product for this course, just a tool to help you create your Azure entries, which the later project will rely upon.

Person Maker vous permet de créer des entrées Azure, qui sont associées à des personnes et à des groupes de personnes.Person Maker allows you to create Azure entries, which are associated with people, and groups of people. L’application place toutes les informations nécessaires dans un format qui peut ensuite être utilisé par le FaceAPI, afin de reconnaître les visages des personnes que vous avez ajoutées.The application will place all the needed information in a format which can then later be used by the FaceAPI, in order to recognize the faces of people whom you have added.

PRÉCIEUSE Person Maker utilise une limitation de base pour s’assurer que vous ne dépassez pas le nombre d’appels de service par minute pour le niveau d’abonnement gratuit.[IMPORTANT] Person Maker uses some basic throttling, to help ensure that you do not exceed the number of service calls per minute for the free subscription tier. Le texte vert en haut devient rouge et met à jour comme « actif » lorsque la limitation se produit ; Si c’est le cas, il vous suffit d’attendre l’application (elle attendra jusqu’à ce qu’elle puisse continuer à accéder au service face, en la mettant à jour comme « en cours » lorsque vous pourrez l’utiliser à nouveau).The green text at the top will change to red and update as 'ACTIVE' when throttling is happening; if this is the case, simply wait for the application (it will wait until it can next continue accessing the face service, updating as 'IN-ACTIVE' when you can use it again).

Cette application utilise les bibliothèques Microsoft. ProjectOxford. face , ce qui vous permet de tirer pleinement parti de la API visage.This application uses the Microsoft.ProjectOxford.Face libraries, which will allow you to make full use of the Face API. Cette bibliothèque est disponible gratuitement en tant que package NuGet.This library is available for free as a NuGet Package. Pour plus d’informations à ce sujet, et les API similaires, veillez à consulter l’article de référence sur les API.For more information about this, and similar, APIs make sure to visit the API reference article.

Notes

Il s’agit uniquement des étapes requises. pour plus d’informations sur la façon de procéder, retrouvez le document.These are just the steps required, instructions for how to do these things is further down the document. L’application Person Maker vous permettra d’effectuer les opérations suivantes :The Person Maker app will allow you to:

  • Créez un groupe de personnes, qui est un groupe composé de plusieurs personnes que vous souhaitez associer à celui-ci.Create a Person Group, which is a group composed of several people which you want to associate with it. Avec votre compte Azure, vous pouvez héberger plusieurs groupes de personnes.With your Azure account you can host multiple Person Groups.

  • Créez une personne, qui est membre d’un groupe de personnes.Create a Person, which is a member of a Person Group. Chaque personne est associée à un certain nombre d’images de face .Each person has a number of Face images associated with it.

  • Attribuez des images de visage à une personne pour permettre à votre service Azure API visage de reconnaître une personne par la face correspondante.Assign face images to a Person, to allow your Azure Face API Service to recognize a Person by the corresponding face.

  • Formez votre service Azure API visage.Train your Azure Face API Service.

N’oubliez pas que pour former cette application et reconnaître des personnes, vous aurez besoin de dix (10) photos proches de chaque personne que vous souhaitez ajouter à votre groupe de personnes.Be aware, so to train this app to recognize people, you will need ten (10) close-up photos of each person which you would like to add to your Person Group. L’application Cam Windows 10 peut vous aider à prendre ces derniers.The Windows 10 Cam App can help you to take these. Vous devez vous assurer que chaque photo est claire (éviter le flou, le masquage ou être trop éloigné, du sujet), que la photo est au format jpg ou png, avec une taille de fichier image supérieure à 4 Mo et inférieure ou égale à 1 Ko.You must ensure that each photo is clear (avoid blurring, obscuring, or being too far, from the subject), have the photo in jpg or png file format, with the image file size being no larger 4 MB, and no less than 1 KB.

Notes

Si vous suivez ce didacticiel, n’utilisez pas votre propre visage pour la formation, comme lorsque vous placez le HoloLens sur, vous ne pouvez pas vous lancer.If you are following this tutorial, do not use your own face for training, as when you put the HoloLens on, you cannot look at yourself. Utilisez le visage d’un collègue ou d’un étudiant.Use the face of a colleague or fellow student.

Créateur de personne en cours d’exécution :Running Person Maker:

  1. Ouvrez le dossier PersonMaker et double-cliquez sur la solution PersonMaker pour l’ouvrir avec Visual Studio.Open the PersonMaker folder and double click on the PersonMaker solution to open it with Visual Studio.

  2. Une fois la solution PersonMaker ouverte, assurez-vous que :Once the PersonMaker solution is open, make sure that:

    1. La configuration de la solution est définie sur Debug.The Solution Configuration is set to Debug.

    2. La plateforme de solution est définie sur x86The Solution Platform is set to x86

    3. La plateforme cible est l' ordinateur local.The Target Platform is Local Machine.

    4. Vous devrez peut-être également restaurer les packages NuGet (cliquez avec le bouton droit sur la solution et sélectionnez restaurer les packages NuGet).You also may need to Restore NuGet Packages (right-click the Solution and select Restore NuGet Packages).

  3. Cliquez sur ordinateur local pour démarrer l’application.Click Local Machine and the application will start. Sachez que, sur des écrans plus petits, tout le contenu peut ne pas être visible, bien que vous puissiez le faire défiler plus loin pour l’afficher.Be aware, on smaller screens, all content may not be visible, though you can scroll further down to view it.

    interface utilisateur person Maker

  4. Insérez votre clé d’authentification Azure, que vous devez avoir, à partir de votre service API visage dans Azure.Insert your Azure Authentication Key, which you should have, from your Face API service within Azure.

  5. Insérer :Insert:

    1. ID à affecter au groupe de personnes.The ID you want to assign to the Person Group. L’ID doit être en minuscules, sans espace.The ID must be lowercase, with no spaces. Notez cet ID, car il sera requis plus tard dans votre projet Unity.Make note of this ID, as it will be required later in your Unity project.
    2. Nom que vous souhaitez attribuer au groupe de personnes (peut avoir des espaces).The Name you want to assign to the Person Group (can have spaces).
  6. Appuyez sur le bouton créer un groupe de personnes .Press Create Person Group button. Un message de confirmation doit s’afficher sous le bouton.A confirmation message should appear underneath the button.

Notes

Si vous avez une erreur « Accès refusé », vérifiez l’emplacement que vous avez défini pour votre service Azure.If you have an 'Access Denied' error, check the location you set for your Azure service. Comme indiqué ci-dessus, cette application est conçue pour « ouest des États-Unis ».As stated above, this app is designed for 'West US'.

Important

Vous remarquerez que vous pouvez également cliquer sur le bouton récupérer un groupe connu : Si vous avez déjà créé un groupe de personnes et que vous souhaitez l’utiliser, plutôt que d’en créer un nouveau.You will notice that you can also click the Fetch a Known Group button: this is for if you have already created a person group, and wish to use that, rather than create a new one. Sachez que si vous cliquez sur créer un groupe de personnes avec un groupe connu, cela permet également de récupérer un groupe.Be aware, if you click Create a Person Group with a known group, this will also fetch a group.

  1. Insérez le nom de la personne que vous souhaitez créer.Insert the Name of the Person you want to create.

    1. Cliquez sur le bouton créer une personne .Click the Create Person button.

    2. Un message de confirmation doit s’afficher sous le bouton.A confirmation message should appear underneath the button.

    3. Si vous souhaitez supprimer une personne que vous avez créée précédemment, vous pouvez écrire le nom dans la zone de texte et appuyer sur Supprimer la personneIf you wish to delete a person you have previously created, you can write the name into the textbox and press Delete Person

  2. Assurez-vous de connaître l’emplacement des dix (10) photos de la personne que vous souhaitez ajouter à votre groupe.Make sure you know the location of ten (10) photos of the person you would like to add to your group.

  3. Appuyez sur créer et ouvrir le dossier pour ouvrir l’Explorateur Windows dans le dossier associé à la personne.Press Create and Open Folder to open Windows Explorer to the folder associated to the person. Ajoutez les dix (10) images dans le dossier.Add the ten (10) images in the folder. Ils doivent être au format de fichier jpg ou png .These must be of JPG or PNG file format.

  4. Cliquez sur Envoyer à Azure.Click on Submit To Azure. Un compteur vous indique l’état de l’envoi, suivi d’un message lorsqu’il est terminé.A counter will show you the state of the submission, followed by a message when it has completed.

  5. Une fois le compteur terminé et un message de confirmation s’affiche, cliquez sur former pour former votre service.Once the counter has finished and a confirmation message has been displayed click on Train to train your Service.

Une fois le processus terminé, vous êtes prêt à passer à Unity.Once the process has completed, you are ready to move into Unity.

Chapitre 3-configurer le projet UnityChapter 3 - Set up the Unity project

Ce qui suit est une configuration classique pour le développement avec une réalité mixte, et, par conséquent, est un bon modèle pour d’autres projets.The following is a typical set up for developing with mixed reality, and as such, is a good template for other projects.

  1. Ouvrez Unity et cliquez sur nouveau.Open Unity and click New.

    Démarrez le nouveau projet Unity.

  2. Vous devez maintenant fournir un nom de projet Unity.You will now need to provide a Unity Project name. Insérez MR_FaceRecognition.Insert MR_FaceRecognition. Assurez-vous que le type de projet est défini sur 3D.Make sure the project type is set to 3D. Définissez l' emplacement approprié pour vous (n’oubliez pas que les répertoires racine sont mieux adaptés).Set the Location to somewhere appropriate for you (remember, closer to root directories is better). Ensuite, cliquez sur créer un projet.Then, click Create project.

    Fournissez des détails pour le nouveau projet Unity.

  3. Si Unity est ouvert, il est conseillé de vérifier que l' éditeur de script par défaut est défini sur Visual Studio.With Unity open, it is worth checking the default Script Editor is set to Visual Studio. Accédez à modifier > préférences puis, dans la nouvelle fenêtre, accédez à outils externes.Go to Edit > Preferences and then from the new window, navigate to External Tools. Remplacez l' éditeur de script externe par Visual Studio 2017.Change External Script Editor to Visual Studio 2017. Fermez la fenêtre Préférences .Close the Preferences window.

    Mettre à jour la préférence éditeur de script.

  4. Accédez ensuite à fichier > paramètres de build et basculez la plateforme sur plateforme Windows universelle, en cliquant sur le bouton changer de plateforme .Next, go to File > Build Settings and switch the platform to Universal Windows Platform, by clicking on the Switch Platform button.

    Fenêtre Paramètres de build, basculez plateforme vers UWP.

  5. Accédez à fichier > paramètres de build et assurez-vous que :Go to File > Build Settings and make sure that:

    1. L' appareil cible est défini sur HoloLensTarget Device is set to HoloLens

      Pour les casques immersifs, définissez appareil cible sur n’importe quel appareil.For the immersive headsets, set Target Device to Any Device.

    2. Le type de build est D3DBuild Type is set to D3D

    3. Le SDK est configuré sur le dernier installéSDK is set to Latest installed

    4. Version de Visual Studio définie sur le dernier installéVisual Studio Version is set to Latest installed

    5. La génération et l’exécution sont définies sur l' ordinateur localBuild and Run is set to Local Machine

    6. Enregistrez la scène et ajoutez-la à la Build.Save the scene and add it to the build.

      1. Pour ce faire, sélectionnez Ajouter des scènes ouvertes.Do this by selecting Add Open Scenes. Une fenêtre d’enregistrement s’affiche.A save window will appear.

        Cliquez sur le bouton Ajouter des scènes ouvertes

      2. Sélectionnez le bouton nouveau dossier pour créer un nouveau dossier, puis nommez-le scenes.Select the New folder button, to create a new folder, name it Scenes.

        Créer un dossier de scripts

      3. Ouvrez le dossier scenes nouvellement créé, puis dans le champ nom de fichier:, tapez FaceRecScene, puis cliquez sur Enregistrer.Open your newly created Scenes folder, and then in the File name: text field, type FaceRecScene, then press Save.

        Donnez un nom à la nouvelle scène.

    7. Les paramètres restants, dans paramètres de build, doivent être laissés par défaut pour le moment.The remaining settings, in Build Settings, should be left as default for now.

  6. Dans la fenêtre paramètres de build , cliquez sur le bouton Paramètres du lecteur pour ouvrir le panneau correspondant dans l’espace où se trouve l' inspecteur .In the Build Settings window, click on the Player Settings button, this will open the related panel in the space where the Inspector is located.

    Ouvrez les paramètres du lecteur.

  7. Dans ce volet, quelques paramètres doivent être vérifiés :In this panel, a few settings need to be verified:

    1. Sous l’onglet autres paramètres :In the Other Settings tab:

      1. La version du runtime de script doit être expérimentale (équivalent .net 4,6).Scripting Runtime Version should be Experimental (.NET 4.6 Equivalent). La modification de cette opération déclenche un besoin de redémarrage de l’éditeur.Changing this will trigger a need to restart the Editor.

      2. Le backend de script doit être .netScripting Backend should be .NET

      3. Le niveau de compatibilité de l’API doit être .net 4,6API Compatibility Level should be .NET 4.6

        Mettez à jour d’autres paramètres.

    2. Dans l’onglet paramètres de publication , sous fonctionnalités, activez la case à cocher :Within the Publishing Settings tab, under Capabilities, check:

      • InternetClientInternetClient

      • WebcamWebcam

        Mise à jour des paramètres de publication.

    3. Plus bas dans le volet, dans les paramètres XR (situés sous paramètres de publication), cochez la réalité virtuelle prise en charge, assurez-vous que le Kit de développement logiciel (SDK) Windows Mixed Reality est ajouté.Further down the panel, in XR Settings (found below Publish Settings), tick Virtual Reality Supported, make sure the Windows Mixed Reality SDK is added.

      Mettez à jour les paramètres X R.

  8. De retour dans les paramètres de build, les projets Unity C# ne sont plus grisés. Cochez la case en regard de cette option.Back in Build Settings, Unity C# Projects is no longer greyed out; tick the checkbox next to this.

  9. Fermez la fenêtre Build Settings.Close the Build Settings window.

  10. Enregistrez votre scène et votre projet (fichier > enregistrer la scène/le fichier > enregistrer le projet).Save your Scene and Project (FILE > SAVE SCENE / FILE > SAVE PROJECT).

Chapitre 4-Configuration de l’appareil photo principalChapter 4 - Main Camera setup

Important

Si vous souhaitez ignorer le composant Unity configure de ce cours et continuer directement dans le code, n’hésitez pas à Télécharger ce fichier. pour Unityet à l’importer dans votre projet en tant que package personnalisé.If you wish to skip the Unity Set up component of this course, and continue straight into code, feel free to download this .unitypackage, and import it into your project as a Custom Package. Sachez que ce package comprend également l’importation de la dll Newtonsoft, traitée dans le Chapitre 5.Be aware that this package also includes the import of the Newtonsoft DLL, covered in Chapter 5. Une fois cette importation effectuée, vous pouvez passer au chapitre 6.With this imported, you can continue from Chapter 6.

  1. Dans le panneau hiérarchie , sélectionnez l' appareil photo principal.In the Hierarchy Panel, select the Main Camera.

  2. Une fois sélectionné, vous pouvez voir tous les composants de la caméra principale dans le panneau Inspecteur.Once selected, you will be able to see all the components of the Main Camera in the Inspector Panel.

    1. L' objet Camera doit être nommé Camera main (Notez l’orthographe !)The Camera object must be named Main Camera (note the spelling!)

    2. La balise principale de l’appareil photo doit être définie sur MainCamera (Notez l’orthographe !)The Main Camera Tag must be set to MainCamera (note the spelling!)

    3. Vérifiez que la position de la transformation est définie sur 0, 0, 0Make sure the Transform Position is set to 0, 0, 0

    4. Définir des indicateurs clairs sur couleur unieSet Clear Flags to Solid Color

    5. Définir la couleur d' arrière-plan du composant Camera sur Black, alpha 0 (Code hexadécimal : #00000000)Set the Background Color of the Camera Component to Black, Alpha 0 (Hex Code: #00000000)

      configurer les composants de l’appareil photo

Chapitre 5-importer le Newtonsoft.Jssur la bibliothèqueChapter 5 – Import the Newtonsoft.Json library

Important

Si vous avez importé le « . pour Unity » dans le dernier chapitre, vous pouvez ignorer ce chapitre.If you imported the '.unitypackage' in the last Chapter, you can skip this Chapter.

Pour vous aider à désérialiser et à sérialiser les objets reçus et envoyés au service bot, vous devez télécharger le Newtonsoft.Jssur la bibliothèque.To help you deserialize and serialize objects received and sent to the Bot Service you need to download the Newtonsoft.Json library. Vous trouverez une version compatible déjà organisée avec la structure de dossiers Unity correcte dans ce fichier de package Unity.You will find a compatible version already organized with the correct Unity folder structure in this Unity package file.

Pour importer la bibliothèque :To import the library:

  1. Téléchargez le package Unity.Download the Unity Package.

  2. Cliquez sur composants, Importer un package, package personnalisé.Click on Assets, Import Package, Custom Package.

    Importer Newtonsoft.Jssur

  3. Recherchez le package Unity que vous avez téléchargé, puis cliquez sur Ouvrir.Look for the Unity Package you have downloaded, and click Open.

  4. Assurez-vous que tous les composants du package sont cochés et cliquez sur Importer.Make sure all the components of the package are ticked and click Import.

    Importer le Newtonsoft.Jssur les ressources

Chapitre 6-créer la classe FaceAnalysisChapter 6 - Create the FaceAnalysis class

L’objectif de la classe FaceAnalysis est d’héberger les méthodes nécessaires pour communiquer avec votre service de reconnaissance faciale Azure.The purpose of the FaceAnalysis class is to host the methods necessary to communicate with your Azure Face Recognition Service.

  • Une fois que le service a envoyé une image de capture, il l’analyse et identifie les visages dans et détermine s’il appartient à une personne connue.After sending the service a capture image, it will analyse it and identify the faces within, and determine if any belong to a known person.
  • Si une personne connue est trouvée, cette classe affiche son nom en tant que texte de l’interface utilisateur dans la scène.If a known person is found, this class will display its name as UI text in the scene.

Pour créer la classe FaceAnalysis :To create the FaceAnalysis class:

  1. Cliquez avec le bouton droit dans le dossier ressources situé dans le panneau projet, puis cliquez sur créer un > dossier.Right-click in the Assets Folder located in the Project Panel, then click on Create > Folder. Appelez le dossier scripts.Call the folder Scripts.

    Créez la classe FaceAnalysis.

  2. Double-cliquez sur le dossier que vous venez de créer pour l’ouvrir.Double click on the folder just created, to open it.

  3. Cliquez avec le bouton droit dans le dossier, puis cliquez sur créer un > script C#.Right-click inside the folder, then click on Create > C# Script. Appelez le script FaceAnalysis.Call the script FaceAnalysis.

  4. Double-cliquez sur le nouveau script FaceAnalysis pour l’ouvrir avec Visual Studio 2017.Double click on the new FaceAnalysis script to open it with Visual Studio 2017.

  5. Entrez les espaces de noms suivants au-dessus de la classe FaceAnalysis :Enter the following namespaces above the FaceAnalysis class:

        using Newtonsoft.Json;
        using System.Collections;
        using System.Collections.Generic;
        using System.IO;
        using System.Text;
        using UnityEngine;
        using UnityEngine.Networking;
    
  6. Vous devez maintenant ajouter tous les objets qui sont utilisés pour deserialising.You now need to add all of the objects which are used for deserialising. Ces objets doivent être ajoutés en dehors du script FaceAnalysis (sous l’accolade inférieure).These objects need to be added outside of the FaceAnalysis script (beneath the bottom curly bracket).

        /// <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. Les méthodes Start () et Update () ne seront pas utilisées. Supprimez-les maintenant.The Start() and Update() methods will not be used, so delete them now.

  8. À l’intérieur de la classe FaceAnalysis , ajoutez les variables suivantes :Inside the FaceAnalysis class, add the following variables:

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

    Notes

    Remplacez la clé et le PersonGroupId par votre clé de service et l’ID du groupe que vous avez créé précédemment.Replace the key and the personGroupId with your Service Key and the Id of the group that you created previously.

  9. Ajoutez la méthode éveillé () , qui initialise la classe, en ajoutant la classe ImageCapture à la caméra principale et en appelant la méthode de création d’étiquette :Add the Awake() method, which initialises the class, adding the ImageCapture class to the Main Camera and calls the Label creation method:

        /// <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. Ajoutez la méthode CreateLabel () , qui crée l’objet label pour afficher le résultat de l’analyse :Add the CreateLabel() method, which creates the Label object to display the analysis result:

        /// <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. Ajoutez la méthode DetectFacesFromImage () et GetImageAsByteArray () .Add the DetectFacesFromImage() and GetImageAsByteArray() method. La première demande au service de reconnaissance faciale de détecter tout visage possible dans l’image envoyée, tandis que ce dernier est nécessaire pour convertir l’image capturée en un tableau d’octets :The former will request the Face Recognition Service to detect any possible face in the submitted image, while the latter is necessary to convert the captured image into a bytes array:

        /// <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. Ajoutez la méthode IdentifyFaces () , qui demande au service de reconnaissance faciale d’identifier toute face connue précédemment détectée dans l’image soumise.Add the IdentifyFaces() method, which requests the Face Recognition Service to identify any known face previously detected in the submitted image. La demande retourne un ID de la personne identifiée, mais pas le nom :The request will return an id of the identified person but not the name:

        /// <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. Ajoutez la méthode GetPerson () .Add the GetPerson() method. En fournissant l’ID de personne, cette méthode demande au service de reconnaissance faciale de retourner le nom de la personne identifiée :By providing the person id, this method then requests for the Face Recognition Service to return the name of the identified person:

        /// <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. N’oubliez pas d' Enregistrer les modifications avant de revenir à l’éditeur Unity.Remember to Save the changes before going back to the Unity Editor.

  15. Dans l’éditeur Unity, faites glisser le script FaceAnalysis du dossier scripts du panneau projet vers l’objet caméra principal dans le panneau hiérarchie.In the Unity Editor, drag the FaceAnalysis script from the Scripts folder in Project panel to the Main Camera object in the Hierarchy panel. Le nouveau composant script sera ajouté à la caméra principale.The new script component will be so added to the Main Camera.

Placer FaceAnalysis sur l’appareil photo principal

Chapitre 7-créer la classe ImageCaptureChapter 7 - Create the ImageCapture class

L’objectif de la classe ImageCapture est d’héberger les méthodes nécessaires pour communiquer avec votre service de reconnaissance faciale Azure afin d’analyser l’image que vous allez capturer, d’identifier les visages et de déterminer si elle appartient à une personne connue.The purpose of the ImageCapture class is to host the methods necessary to communicate with your Azure Face Recognition Service to analyse the image you will capture, identifying faces in it and determining if it belongs to a known person. Si une personne connue est trouvée, cette classe affiche son nom en tant que texte de l’interface utilisateur dans la scène.If a known person is found, this class will display its name as UI text in the scene.

Pour créer la classe ImageCapture :To create the ImageCapture class:

  1. Cliquez avec le bouton droit dans le dossier scripts que vous avez créé précédemment, puis cliquez sur créer, script C#.Right-click inside the Scripts folder you have created previously, then click on Create, C# Script. Appelez le script ImageCapture.Call the script ImageCapture.

  2. Double-cliquez sur le nouveau script ImageCapture pour l’ouvrir avec Visual Studio 2017.Double click on the new ImageCapture script to open it with Visual Studio 2017.

  3. Entrez les espaces de noms suivants au-dessus de la classe ImageCapture :Enter the following namespaces above the ImageCapture class:

        using System.IO;
        using System.Linq;
        using UnityEngine;
        using UnityEngine.XR.WSA.Input;
        using UnityEngine.XR.WSA.WebCam;
    
  4. À l’intérieur de la classe ImageCapture , ajoutez les variables suivantes :Inside the ImageCapture class, add the following variables:

        /// <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. Ajoutez les méthodes éveillé () et Start () nécessaires à l’initialisation de la classe et autorisez le HoloLens à capturer les mouvements de l’utilisateur :Add the Awake() and Start() methods necessary to initialise the class and allow the HoloLens to capture the user's gestures:

        /// <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. Ajoutez le TapHandler () qui est appelé lorsque l’utilisateur effectue un mouvement Tap :Add the TapHandler() which is called when the user performs a Tap gesture:

        /// <summary>
        /// Respond to Tap Input.
        /// </summary>
        private void TapHandler(TappedEventArgs obj)
        {
            tapsCount++;
            ExecuteImageCaptureAndAnalysis();
        }
    
  7. Ajoutez la méthode ExecuteImageCaptureAndAnalysis () , qui va commencer le processus de capture d’image :Add the ExecuteImageCaptureAndAnalysis() method, which will begin the process of Image Capturing:

        /// <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. Ajoutez les gestionnaires qui sont appelés lorsque le processus de capture de photos est terminé :Add the handlers that are called when the photo capture process has been completed:

        /// <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. N’oubliez pas d' Enregistrer les modifications avant de revenir à l’éditeur Unity.Remember to Save the changes before going back to the Unity Editor.

Chapitre 8-génération de la solutionChapter 8 - Building the solution

Pour effectuer un test minutieux de votre application, vous devez l’chargement sur votre HoloLens.To perform a thorough test of your application you will need to sideload it onto your HoloLens.

Avant cela, assurez-vous que :Before you do, ensure that:

  • Tous les paramètres mentionnés dans le chapitre 3 sont correctement définis.All the settings mentioned in the Chapter 3 are set correctly.
  • Le script FaceAnalysis est attaché à l’objet Camera principal.The script FaceAnalysis is attached to the Main Camera object.
  • La clé d’authentification et l' ID de groupe ont été définis dans le script FaceAnalysis .Both the Auth Key and Group Id have been set within the FaceAnalysis script.

R ce point vous êtes prêt à générer la solution.A this point you are ready to build the Solution. Une fois la solution générée, vous êtes prêt à déployer votre application.Once the Solution has been built, you will be ready to deploy your application.

Pour commencer le processus de génération :To begin the Build process:

  1. Enregistrez la scène en cours en cliquant sur fichier, puis sur Enregistrer.Save the current scene by clicking on File, Save.

  2. Accédez à fichier, paramètres de build, puis cliquez sur Ajouter des scènes ouvertes.Go to File, Build Settings, click on Add Open Scenes.

  3. Veillez à cocher les projets Unity C#.Make sure to tick Unity C# Projects.

    Déployer la solution Visual Studio

  4. Appuyez sur générer.Press Build. Dans ce cas, Unity lance une fenêtre de l’Explorateur de fichiers, où vous devez créer, puis sélectionner un dossier dans lequel créer l’application.Upon doing so, Unity will launch a File Explorer window, where you need to create and then select a folder to build the app into. Créez ce dossier maintenant, dans le projet Unity, et appelez-le.Create that folder now, within the Unity project, and call it App. Ensuite, avec le dossier d’application sélectionné, appuyez sur Sélectionner un dossier.Then with the App folder selected, press Select Folder.

  5. Unity commence à générer votre projet, en dehors du dossier de l’application.Unity will begin building your project, out to the App folder.

  6. Une fois la génération de Unity terminée (cela peut prendre un certain temps), une fenêtre de l’Explorateur de fichiers s’ouvre à l’emplacement de votre Build.Once Unity has finished building (it might take some time), it will open a File Explorer window at the location of your build.

    Déployer la solution à partir de Visual Studio

  7. Ouvrez le dossier de votre application, puis ouvrez la solution nouveau projet (comme indiqué ci-dessus, MR_FaceRecognition. sln).Open your App folder, and then open the new Project Solution (as seen above, MR_FaceRecognition.sln).

Chapitre 9-déploiement de votre applicationChapter 9 - Deploying your application

Pour effectuer un déploiement sur HoloLens :To deploy on HoloLens:

  1. Vous aurez besoin de l’adresse IP de votre HoloLens (pour le déploiement à distance) et vérifiez que votre HoloLens est en mode développeur.You will need the IP Address of your HoloLens (for Remote Deploy), and to ensure your HoloLens is in Developer Mode. Pour ce faire :To do this:

    1. Tout en portant votre HoloLens, ouvrez les paramètres.Whilst wearing your HoloLens, open the Settings.
    2. Accéder au réseau & Internet > Wi-Fi options avancées >Go to Network & Internet > Wi-Fi > Advanced Options
    3. Notez l’adresse IPv4 .Note the IPv4 address.
    4. Ensuite, revenez aux paramètres, puis à mettre à jour & > de sécurité pour les développeursNext, navigate back to Settings, and then to Update & Security > For Developers
    5. Définissez le mode développeur sur.Set Developer Mode On.
  2. Accédez à votre nouvelle build Unity (le dossier de l' application ) et ouvrez le fichier solution avec Visual Studio.Navigate to your new Unity build (the App folder) and open the solution file with Visual Studio.

  3. Dans la configuration de la solution, sélectionnez Déboguer.In the Solution Configuration select Debug.

  4. Dans la plateforme de la solution, sélectionnez x86, ordinateur distant.In the Solution Platform, select x86, Remote Machine.

    Modifier la configuration de la solution

  5. Accédez au menu Générer , puis cliquez sur déployer la solution pour chargement l’application à votre HoloLens.Go to the Build menu and click on Deploy Solution, to sideload the application to your HoloLens.

  6. Votre application doit maintenant apparaître dans la liste des applications installées sur votre HoloLens, prête à être lancée.Your App should now appear in the list of installed apps on your HoloLens, ready to be launched!

Notes

Pour effectuer un déploiement sur un casque immersif, définissez la plateforme de la solution sur ordinateur local et définissez la configuration sur Déboguer, avec x86 comme plateforme.To deploy to immersive headset, set the Solution Platform to Local Machine, and set the Configuration to Debug, with x86 as the Platform. Déployez ensuite sur l’ordinateur local, à l’aide du menu Générer, en sélectionnant déployer la solution.Then deploy to the local machine, using the Build menu, selecting Deploy Solution.

Chapitre 10-utilisation de l’applicationChapter 10 - Using the application

  1. Porter le HoloLens, lancer l’application.Wearing the HoloLens, launch the app.

  2. Examinez la personne que vous avez inscrite auprès du API visage.Look at the person that you have registered with the Face API. Assurez-vous que :Make sure that:

    • Le visage de la personne n’est pas trop éloigné et clairement visibleThe person's face is not too distant and clearly visible
    • L’éclairage de l’environnement n’est pas trop sombreThe environment lighting is not too dark
  3. Utilisez le geste TAP pour capturer l’image de la personne.Use the tap gesture to capture the person's picture.

  4. Attendez que l’application envoie la demande d’analyse et que vous receviez une réponse.Wait for the App to send the analysis request and receive a response.

  5. Si la personne a été correctement reconnue, le nom de la personne s’affiche comme texte de l’interface utilisateur.If the person has been successfully recognized, the person's name will appear as UI text.

  6. Vous pouvez répéter le processus de capture à l’aide du geste TAP (TAP) toutes les quelques secondes.You can repeat the capture process using the tap gesture every few seconds.

Votre application Azure API Visage terminéeYour finished Azure Face API Application

Félicitations, vous avez créé une application de réalité mixte qui tire parti du service de reconnaissance faciale Azure pour détecter les visages au sein d’une image et identifier les visages connus.Congratulations, you built a mixed reality app that leverages the Azure Face Recognition service to detect faces within an image, and identify any known faces.

résultat de la fin de ce cours

Exercices bonusBonus exercises

Exercice 1Exercise 1

Le API visage Azure est suffisamment puissant pour détecter jusqu’à 64 faces dans une image unique.The Azure Face API is powerful enough to detect up to 64 faces in a single image. Étendez l’application afin qu’elle puisse reconnaître deux ou trois visages, parmi de nombreuses autres personnes.Extend the application, so that it could recognize two or three faces, amongst many other people.

Exercice 2Exercise 2

Le API visage Azure est également en mesure de fournir toutes sortes d’informations sur les attributs.The Azure Face API is also able to provide back all kinds of attribute information. Intégrez cela dans l’application.Integrate this into the application. Cela peut être encore plus intéressant, lorsqu’il est associé au API émotion.This could be even more interesting, when combined with the Emotion API.