Observação

Os tutoriais misturados do Academia de realidade foram projetados com o HoloLens (1º gen) e com o fone de cabeça de imersão de realidade misturada.The Mixed Reality Academy tutorials were designed with HoloLens (1st gen) and Mixed Reality Immersive Headsets in mind. Como tal, achamos que é importante deixar esses tutoriais em vigor para os desenvolvedores que ainda estão procurando orientação no desenvolvimento para esses dispositivos.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. Esses tutoriais não serão atualizados com os conjuntos de ferramentas e as interações mais recentes usados para o HoloLens 2.These tutorials will not be updated with the latest toolsets or interactions being used for HoloLens 2. Eles serão mantidos para continuar a trabalhar nos dispositivos com suporte.They will be maintained to continue working on the supported devices. Haverá uma nova série de tutoriais que serão publicados no futuro, que demonstrarão como desenvolver para o 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. Esse aviso será atualizado com um link para esses tutoriais quando eles forem postados.This notice will be updated with a link to those tutorials when they are posted.


Sr e Azure 304: reconhecimento facialMR and Azure 304: Face recognition

resultado da conclusão deste curso

Neste curso, você aprenderá a adicionar recursos de reconhecimento facial a um aplicativo de realidade misturada, usando os serviços cognitivas do Azure, com o Microsoft API de Detecção Facial.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.

O Azure API de detecção facial é um serviço da Microsoft, que fornece aos desenvolvedores os algoritmos de face mais avançados, tudo na nuvem.Azure Face API is a Microsoft service, which provides developers with the most advanced face algorithms, all in the cloud. O API de detecção facial tem duas funções principais: detecção facial com atributos e reconhecimento facial.The Face API has two main functions: face detection with attributes, and face recognition. Isso permite que os desenvolvedores simplesmente definam um conjunto de grupos para rostos e, em seguida, enviem imagens de consulta para o serviço posteriormente, para determinar a quem uma face pertence.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. Para obter mais informações, visite a página de reconhecimento de face do Azure.For more information, visit the Azure Face Recognition page.

Após a conclusão deste curso, você terá um aplicativo de HoloLens de realidade misturada, que poderá fazer o seguinte:Having completed this course, you will have a mixed reality HoloLens application, which will be able to do the following:

  1. Use um gesto de toque para iniciar a captura de uma imagem usando a câmera do HoloLens na placa.Use a Tap Gesture to initiate the capture of an image using the on-board HoloLens camera.
  2. Envie a imagem capturada para o serviço de API de detecção facial do Azure .Send the captured image to the Azure Face API service.
  3. Receba os resultados do algoritmo API de detecção facial .Receive the results of the Face API algorithm.
  4. Use uma interface do usuário simples para exibir o nome de pessoas correspondentes.Use a simple User Interface, to display the name of matched people.

Isso ensinará a você como obter os resultados do serviço de API de Detecção Facial em seu aplicativo de realidade mista com base no Unity.This will teach you how to get the results from the Face API Service into your Unity-based mixed reality application.

Em seu aplicativo, cabe a você como você integrará os resultados com seu design.In your application, it is up to you as to how you will integrate the results with your design. Este curso foi projetado para ensinar a você como integrar um serviço do Azure com seu projeto do Unity.This course is designed to teach you how to integrate an Azure Service with your Unity Project. É seu trabalho usar o conhecimento obtido deste curso para aprimorar seu aplicativo de realidade misturada.It is your job to use the knowledge you gain from this course to enhance your mixed reality application.

Suporte a dispositivosDevice support

CourseCourse HoloLensHoloLens Headsets imersivosImmersive headsets
Sr e Azure 304: reconhecimento facialMR and Azure 304: Face recognition ✔️✔️ ✔️✔️

Observação

Embora este curso se concentre principalmente no HoloLens, você também pode aplicar o que aprende neste curso a fones de ouvido (VR) de realidade mista do Windows.While this course primarily focuses on HoloLens, you can also apply what you learn in this course to Windows Mixed Reality immersive (VR) headsets. Como os headsets de imersão (VR) não têm câmeras acessíveis, você precisará de uma câmera externa conectada ao seu PC.Because immersive (VR) headsets do not have accessible cameras, you will need an external camera connected to your PC. Ao acompanhar o curso, você verá observações sobre as alterações que talvez precise empregar para dar suporte a headsets de imersão (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é-requisitosPrerequisites

Observação

Este tutorial foi desenvolvido para desenvolvedores que têm experiência básica com o Unity C#e o.This tutorial is designed for developers who have basic experience with Unity and C#. Além disso, lembre-se de que os pré-requisitos e as instruções escritas neste documento representam o que foi testado e verificado no momento da gravação (maio de 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). Você está livre para usar o software mais recente, conforme listado no artigo instalar as ferramentas , embora não seja recomendável que as informações neste curso irão se adequar perfeitamente ao que você encontrará em softwares mais recentes do que as listadas abaixo.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.

Recomendamos o seguinte hardware e software para este curso:We recommend the following hardware and software for this course:

Antes de começarBefore you start

  1. Para evitar problemas de criação desse projeto, é altamente recomendável que você crie o projeto mencionado neste tutorial em uma pasta raiz ou quase raiz (caminhos de pasta longos podem causar problemas em tempo de compilação).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. Configure e teste seu HoloLens.Set up and test your HoloLens. Se você precisar de suporte para configurar seu HoloLens, visite o artigo configuração do hololens.If you need support setting up your HoloLens, make sure to visit the HoloLens setup article.
  3. É uma boa ideia executar a calibragem e o ajuste do sensor ao começar a desenvolver um novo aplicativo do HoloLens (às vezes, ele pode ajudar a executar essas tarefas para cada usuário).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).

Para obter ajuda sobre calibragem, siga este link para o artigo Calibration do HoloLens.For help on Calibration, please follow this link to the HoloLens Calibration article.

Para obter ajuda sobre o ajuste do sensor, siga este link para o artigo de ajuste do sensor do HoloLens.For help on Sensor Tuning, please follow this link to the HoloLens Sensor Tuning article.

Capítulo 1-o portal do AzureChapter 1 - The Azure Portal

Para usar o serviço de API de detecção facial no Azure, você precisará configurar uma instância do serviço a ser disponibilizada para seu aplicativo.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. Primeiro, faça logon no portal do Azure.First, log in to the Azure Portal.

    Observação

    Se você ainda não tiver uma conta do Azure, será necessário criar uma.If you do not already have an Azure account, you will need to create one. Se você estiver seguindo este tutorial em uma situação de sala de aula ou laboratório, peça ao instrutor ou a uma das proctors para obter ajuda para configurar sua nova conta.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. Depois de fazer logon, clique em novo no canto superior esquerdo e procure API de detecção facial, pressione Enter.Once you are logged in, click on New in the top left corner, and search for Face API, press Enter.

    Pesquisar API de detecção facial

    Observação

    A palavra novo pode ter sido substituída por criar um recurso, em portais mais recentes.The word New may have been replaced with Create a resource, in newer portals.

  3. A nova página fornecerá uma descrição do serviço API de detecção facial .The new page will provide a description of the Face API service. Na parte inferior esquerda desse prompt, selecione o botão criar para criar uma associação com esse serviço.At the bottom left of this prompt, select the Create button, to create an association with this service.

    informações da API facial

  4. Depois de clicar em criar:Once you have clicked on Create:

    1. Insira o nome desejado para esta instância de serviço.Insert your desired name for this service instance.

    2. Selecione uma assinatura.Select a subscription.

    3. Selecione o tipo de preço apropriado para você, se esta for a primeira vez que criar um serviço de API de detecção facial, uma camada gratuita (chamada F0) deverá estar disponível para você.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. Escolha um grupo de recursos ou crie um novo.Choose a Resource Group or create a new one. Um grupo de recursos fornece uma maneira de monitorar, controlar o acesso, provisionar e gerenciar a cobrança de uma coleção de ativos do Azure.A resource group provides a way to monitor, control access, provision and manage billing for a collection of Azure assets. É recomendável manter todos os serviços do Azure associados a um único projeto (por exemplo, esses laboratórios) em um grupo de recursos comum).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).

      Se você quiser ler mais sobre grupos de recursos do Azure, visite o artigo grupo de recursos.If you wish to read more about Azure Resource Groups, please visit the resource group article.

    5. O aplicativo UWP, criador de pessoas, que você usa mais tarde, requer o uso de ' oeste dos EUA ' para o local.The UWP app, Person Maker, which you use later, requires the use of 'West US' for location.

    6. Você também precisará confirmar que entendeu os termos e condições aplicados a esse serviço.You will also need to confirm that you have understood the Terms and Conditions applied to this Service.

    7. Selecione **criar *.**Select Create*.

      Criar serviço de API facial

  5. Depois de clicar em *criar , você precisará aguardar a criação do serviço; isso pode levar um minuto.Once you have clicked on Create*, you will have to wait for the service to be created, this might take a minute.

  6. Uma notificação será exibida no portal assim que a instância do serviço for criada.A notification will appear in the portal once the Service instance is created.

    notificação de criação de serviço

  7. Clique nas notificações para explorar sua nova instância de serviço.Click on the notifications to explore your new Service instance.

    ir para notificação de recurso

  8. Quando estiver pronto, clique no botão ir para o recurso na notificação para explorar sua nova instância de serviço.When you are ready, click Go to resource button in the notification to explore your new Service instance.

    acessar chaves de API de face

  9. Neste tutorial, seu aplicativo precisará fazer chamadas para seu serviço, o que é feito por meio do uso da assinatura ' Key ' de seu serviço.Within this tutorial, your application will need to make calls to your service, which is done through using your service's subscription 'key'. Na página início rápido , do seu serviço de API de detecção facial , o primeiro ponto é o número 1, para captar suas chaves.From the Quick start page, of your Face API service, the first point is number 1, to Grab your keys.

  10. Na página serviço , selecione o hiperlink teclas azuis (se estiver na página início rápido) ou o link chaves no menu de navegação serviços (à esquerda, indicado pelo ícone "chave"), para revelar suas chaves.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.

    Observação

    Anote qualquer uma das chaves e proteja-a, pois você precisará dela mais tarde.Take note of either one of the keys and safeguard it, as you will need it later.

Capítulo 2-usando o aplicativo UWP do ' criador de pessoas 'Chapter 2 - Using the 'Person Maker' UWP application

Certifique-se de baixar o aplicativo UWP pré-criado chamado Person Maker.Make sure to download the prebuilt UWP Application called Person Maker. Este aplicativo não é o produto final para este curso, apenas uma ferramenta para ajudá-lo a criar suas entradas do Azure, com as quais o projeto posterior dependerá.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.

O criador de pessoas permite que você crie entradas do Azure, que estão associadas a pessoas e grupos de pessoas.Person Maker allows you to create Azure entries, which are associated with people, and groups of people. O aplicativo coloca todas as informações necessárias em um formato que, posteriormente, pode ser usado pelo FaceAPI para reconhecer as faces de pessoas que você adicionou.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.

FUNDAMENTAL O criador de pessoas usa uma limitação básica para ajudar a garantir que você não exceda o número de chamadas de serviço por minuto para a camada de assinatura gratuita.[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. O texto verde na parte superior mudará para vermelho e será atualizado como ' ativo ' quando a limitação estiver acontecendo; Se esse for o caso, basta aguardar o aplicativo (ele aguardará até que possa continuar acessando o serviço de face, atualizando como ' IN-ACTIVE ' quando você puder usá-lo novamente).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).

Esse aplicativo usa as bibliotecas Microsoft. ProjectOxford. facial , que permitirão que você faça uso completo da API de detecção facial.This application uses the Microsoft.ProjectOxford.Face libraries, which will allow you to make full use of the Face API. Essa biblioteca está disponível gratuitamente como um pacote NuGet.This library is available for free as a NuGet Package. Para obter mais informações sobre isso e APIs semelhantes, visite o artigo de referência de API.For more information about this, and similar, APIs make sure to visit the API reference article.

Observação

Essas são apenas as etapas necessárias, as instruções sobre como fazer essas coisas estão mais abaixo do documento.These are just the steps required, instructions for how to do these things is further down the document. O aplicativo Person Maker lhe permitirá:The Person Maker app will allow you to:

  • Crie um grupo de pessoas, que é um grupo composto por várias pessoas que você deseja associar a ela.Create a Person Group, which is a group composed of several people which you want to associate with it. Com sua conta do Azure, você pode hospedar vários grupos de pessoas.With your Azure account you can host multiple Person Groups.

  • Crie uma pessoa, que é um membro de um grupo de pessoas.Create a Person, which is a member of a Person Group. Cada pessoa tem várias imagens de face associadas a ela.Each person has a number of Face images associated with it.

  • Atribua imagens de face a uma pessoa, para permitir que o serviço de API de detecção facial do Azure reconheça uma pessoa pela facecorrespondente.Assign face images to a Person, to allow your Azure Face API Service to recognize a Person by the corresponding face.

  • Treine seu serviço de API de detecção facial do Azure.Train your Azure Face API Service.

Lembre-se de que, para treinar esse aplicativo para reconhecer pessoas, você precisará de dez (10) fotos de fechamento de cada pessoa que deseja adicionar ao seu grupo de pessoas.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. O aplicativo de Cam do Windows 10 pode ajudá-lo a fazer isso.The Windows 10 Cam App can help you to take these. Você deve garantir que cada foto esteja clara (Evite desfocar, obscurecer ou estar muito longe, do assunto), ter a foto no formato de arquivo jpg ou png, com o tamanho do arquivo de imagem que não seja maior que 4 MBe não seja menor que 1 KB.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.

Observação

Se você estiver seguindo este tutorial, não use sua própria face para treinamento, como quando você coloca o HoloLens em, você não pode examinar por conta própria.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. Use a face de um colega ou colega de aluno.Use the face of a colleague or fellow student.

Criador de pessoasem execução:Running Person Maker:

  1. Abra a pasta PersonMaker e clique duas vezes na solução PersonMaker para abri-la com o Visual Studio.Open the PersonMaker folder and double click on the PersonMaker solution to open it with Visual Studio.

  2. Depois que a solução PersonMaker estiver aberta, verifique se:Once the PersonMaker solution is open, make sure that:

    1. A configuração da solução está definida como depurar.The Solution Configuration is set to Debug.

    2. A plataforma da solução está definida como x86The Solution Platform is set to x86

    3. A plataforma de destino é a máquina local.The Target Platform is Local Machine.

    4. Talvez você também precise restaurar os pacotes NuGet (clique com o botão direito do mouse na solução e selecione restaurar pacotes NuGet).You also may need to Restore NuGet Packages (right-click the Solution and select Restore NuGet Packages).

  3. Clique em computador local e o aplicativo será iniciado.Click Local Machine and the application will start. Lembre-se de que, em telas menores, todo o conteúdo pode não estar visível, embora você possa rolar mais para baixo para exibi-lo.Be aware, on smaller screens, all content may not be visible, though you can scroll further down to view it.

    interface do usuário do criador de pessoas

  4. Insira sua chave de autenticação do Azure, que você deve ter, do seu serviço de API de detecção facial no Azure.Insert your Azure Authentication Key, which you should have, from your Face API service within Azure.

  5. InseridoInsert:

    1. A ID que você deseja atribuir ao grupo de pessoas.The ID you want to assign to the Person Group. A ID deve estar em minúsculas, sem espaços.The ID must be lowercase, with no spaces. Anote essa ID, pois ela será necessária mais tarde no seu projeto do Unity.Make note of this ID, as it will be required later in your Unity project.
    2. O nome que você deseja atribuir ao grupo de pessoas (pode ter espaços).The Name you want to assign to the Person Group (can have spaces).
  6. Pressione o botão Criar grupo de pessoas .Press Create Person Group button. Uma mensagem de confirmação deve aparecer abaixo do botão.A confirmation message should appear underneath the button.

Observação

Se você tiver um erro de ' acesso negado ', verifique o local definido para o serviço do Azure.If you have an 'Access Denied' error, check the location you set for your Azure service. Conforme mencionado acima, este aplicativo foi projetado para o "oeste dos EUA".As stated above, this app is designed for 'West US'.

Importante

Você observará que também pode clicar no botão buscar um grupo conhecido : isso ocorrerá se você já tiver criado um grupo de pessoas e quiser usá-lo, em vez de criar um novo.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. Lembre-se de que, se você clicar em criar um grupo de pessoas com um grupo conhecido, isso também obterá um grupo.Be aware, if you click Create a Person Group with a known group, this will also fetch a group.

  1. Insira o nome da pessoa que você deseja criar.Insert the Name of the Person you want to create.

    1. Clique no botão criar pessoa .Click the Create Person button.

    2. Uma mensagem de confirmação deve aparecer abaixo do botão.A confirmation message should appear underneath the button.

    3. Se desejar excluir uma pessoa que você criou anteriormente, você poderá escrever o nome na caixa de texto e pressionar excluir pessoaIf you wish to delete a person you have previously created, you can write the name into the textbox and press Delete Person

  2. Verifique se você sabe o local de dez (dez) fotos da pessoa que deseja adicionar ao seu grupo.Make sure you know the location of ten (10) photos of the person you would like to add to your group.

  3. Pressione criar e abrir pasta para abrir o Windows Explorer na pasta associada à pessoa.Press Create and Open Folder to open Windows Explorer to the folder associated to the person. Adicione as dez (10) imagens na pasta.Add the ten (10) images in the folder. Eles devem ser do formato de arquivo jpg ou png .These must be of JPG or PNG file format.

  4. Clique em Enviar para o Azure.Click on Submit To Azure. Um contador mostrará o estado do envio, seguido por uma mensagem quando for concluído.A counter will show you the state of the submission, followed by a message when it has completed.

  5. Depois que o contador for concluído e uma mensagem de confirmação for exibida, clique em treinar para treinar o serviço.Once the counter has finished and a confirmation message has been displayed click on Train to train your Service.

Depois que o processo for concluído, você estará pronto para passar para o Unity.Once the process has completed, you are ready to move into Unity.

Capítulo 3 – configurar o projeto do UnityChapter 3 - Set up the Unity project

A seguir está uma configuração típica para o desenvolvimento com realidade misturada e, como tal, é um bom modelo para outros projetos.The following is a typical set up for developing with mixed reality, and as such, is a good template for other projects.

  1. Abra o Unity e clique em novo.Open Unity and click New.

    Inicie o novo projeto do Unity.

  2. Agora, você precisará fornecer um nome de projeto de Unity.You will now need to provide a Unity Project name. Inserir MR_FaceRecognition.Insert MR_FaceRecognition. Verifique se o tipo de projeto está definido como 3D.Make sure the project type is set to 3D. Defina o local como algum lugar apropriado para você (Lembre-se de que, mais próximo de diretórios raiz é melhor).Set the Location to somewhere appropriate for you (remember, closer to root directories is better). Em seguida, clique em criar projeto.Then, click Create project.

    Forneça detalhes para o novo projeto do Unity.

  3. Com o Unity Open, vale a pena verificar se o Editor de script padrão está definido como Visual Studio.With Unity open, it is worth checking the default Script Editor is set to Visual Studio. Vá para Editar preferências de > e, em seguida, na nova janela, navegue até Ferramentas externas.Go to Edit > Preferences and then from the new window, navigate to External Tools. Altere o Editor de script externo para o Visual Studio 2017.Change External Script Editor to Visual Studio 2017. Feche a janela preferências .Close the Preferences window.

    Atualize a preferência do editor de script.

  4. Em seguida, vá para arquivo > configurações de Build e alterne a plataforma para plataforma universal do Windowsclicando no botão alternar plataforma .Next, go to File > Build Settings and switch the platform to Universal Windows Platform, by clicking on the Switch Platform button.

    Janela de configurações de compilação, alterne a plataforma para UWP.

  5. Vá para arquivo > configurações de compilação e verifique se:Go to File > Build Settings and make sure that:

    1. O dispositivo de destino está definido como HoloLensTarget Device is set to HoloLens

      Para os headsets de imersão, defina dispositivo de destino para qualquer dispositivo.For the immersive headsets, set Target Device to Any Device.

    2. O tipo de compilação está definido como D3DBuild Type is set to D3D

    3. O SDK está definido para o mais recente instaladoSDK is set to Latest installed

    4. A versão do Visual Studio está definida para o mais recente instaladoVisual Studio Version is set to Latest installed

    5. Compilar e executar é definido como computador localBuild and Run is set to Local Machine

    6. Salve a cena e adicione-a à compilação.Save the scene and add it to the build.

      1. Faça isso selecionando Adicionar abrir cenas.Do this by selecting Add Open Scenes. Uma janela salvar será exibida.A save window will appear.

        Clique no botão Adicionar cenas abertas

      2. Selecione o botão nova pasta , para criar uma nova pasta, nomeie-a como cenas.Select the New folder button, to create a new folder, name it Scenes.

        Criar nova pasta de scripts

      3. Abra sua pasta de cenas recém-criada e, no campo nome do arquivo:, digite FaceRecScenee pressione salvar.Open your newly created Scenes folder, and then in the File name: text field, type FaceRecScene, then press Save.

        Dê um nome à nova cena.

    7. As configurações restantes, em configurações de compilação, devem ser deixadas como padrão por enquanto.The remaining settings, in Build Settings, should be left as default for now.

  6. Na janela configurações de compilação , clique no botão configurações do Player , isso abrirá o painel relacionado no espaço onde o Inspetor está localizado.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.

    Abra as configurações do Player.

  7. Nesse painel, algumas configurações precisam ser verificadas:In this panel, a few settings need to be verified:

    1. Na guia outras configurações :In the Other Settings tab:

      1. A versão de tempo de execução de script deve ser experimental (.NET 4,6 equivalente).Scripting Runtime Version should be Experimental (.NET 4.6 Equivalent). Alterar isso irá disparar a necessidade de reiniciar o editor.Changing this will trigger a need to restart the Editor.

      2. O back-end de script deve ser .netScripting Backend should be .NET

      3. O nível de compatibilidade da API deve ser .NET 4,6API Compatibility Level should be .NET 4.6

        Atualize outras configurações.

    2. Na guia configurações de publicação , em recursos, marque:Within the Publishing Settings tab, under Capabilities, check:

      • InternetClientInternetClient

      • IntegradaWebcam

        Atualizando configurações de publicação.

    3. Mais adiante no painel, em configurações de XR (encontradas abaixo de configurações de publicação), suporte à realidade virtualem escala, verifique se o SDK do Windows Mixed Reality foi adicionado.Further down the panel, in XR Settings (found below Publish Settings), tick Virtual Reality Supported, make sure the Windows Mixed Reality SDK is added.

      Atualize as configurações de X R.

  8. De volta às configurações de compilação, os projetos de C# Unity não ficam mais esmaecidos; Marque a caixa de seleção ao lado deste.Back in Build Settings, Unity C# Projects is no longer greyed out; tick the checkbox next to this.

  9. Feche a janela configurações de compilação.Close the Build Settings window.

  10. Salve sua cena e projeto (arquivo > salvar cena/arquivo > salvar projeto).Save your Scene and Project (FILE > SAVE SCENE / FILE > SAVE PROJECT).

Capítulo 4-configuração principal da câmeraChapter 4 - Main Camera setup

Importante

Se você quiser ignorar o componente de configuração do Unity deste curso e continuar diretamente no código, fique à vontade para baixar esse. unitypackagee importe-o para seu projeto como um pacote personalizado.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. Lembre-se de que esse pacote também inclui a importação da dll Newtonsoft, abordada no capítulo 5.Be aware that this package also includes the import of the Newtonsoft DLL, covered in Chapter 5. Com isso importado, você pode continuar no capítulo 6.With this imported, you can continue from Chapter 6.

  1. No painel hierarquia , selecione a câmera principal.In the Hierarchy Panel, select the Main Camera.

  2. Depois de selecionado, você poderá ver todos os componentes da câmera principal no painel Inspetor.Once selected, you will be able to see all the components of the Main Camera in the Inspector Panel.

    1. O objeto de câmera deve ser nomeado como a câmera principal (Observe a grafia!)The Camera object must be named Main Camera (note the spelling!)

    2. A marca da câmera principal deve ser definida como MainCamera (Observe a ortografia!)The Main Camera Tag must be set to MainCamera (note the spelling!)

    3. Verifique se a posição de transformação está definida como 0, 0, 0Make sure the Transform Position is set to 0, 0, 0

    4. Definir sinalizadores de limpeza como cor sólidaSet Clear Flags to Solid Color

    5. Defina a cor do plano de fundo do componente da câmera como preto, alfa 0 (código hex: #00000000)Set the Background Color of the Camera Component to Black, Alpha 0 (Hex Code: #00000000)

      configurar componentes da câmera

Capítulo 5 – importar a biblioteca Newtonsoft. JSONChapter 5 – Import the Newtonsoft.Json library

Importante

Se você importou o '. unitypackage ' no último capítulo, poderá ignorar este capítulo.If you imported the '.unitypackage' in the last Chapter, you can skip this Chapter.

Para ajudá-lo a desserializar e serializar objetos recebidos e enviados ao serviço bot, você precisa baixar a biblioteca Newtonsoft. JSON .To help you deserialize and serialize objects received and sent to the Bot Service you need to download the Newtonsoft.Json library. Você encontrará uma versão compatível já organizada com a estrutura de pasta do Unity correta neste arquivo de pacote do Unity.You will find a compatible version already organized with the correct Unity folder structure in this Unity package file.

Para importar a biblioteca:To import the library:

  1. Baixe o pacote do Unity.Download the Unity Package.

  2. Clique em ativos, Importar pacote, pacote personalizado.Click on Assets, Import Package, Custom Package.

    Importar a biblioteca Newtonsoft. JSON

  3. Procure o pacote do Unity que você baixou e clique em abrir.Look for the Unity Package you have downloaded, and click Open.

  4. Verifique se todos os componentes do pacote estão com tique e clique em importar.Make sure all the components of the package are ticked and click Import.

    Importar a biblioteca Newtonsoft. JSON

Capítulo 6-criar a classe FaceAnalysisChapter 6 - Create the FaceAnalysis class

A finalidade da classe FaceAnalysis é hospedar os métodos necessários para se comunicar com o serviço de reconhecimento de face do Azure.The purpose of the FaceAnalysis class is to host the methods necessary to communicate with your Azure Face Recognition Service.

  • Depois de enviar a imagem de captura do serviço, ela a analisará e identificará as faces dentro e determinará se alguém pertence a uma pessoa conhecida.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.
  • Se uma pessoa conhecida for encontrada, essa classe exibirá seu nome como texto da interface do usuário na cena.If a known person is found, this class will display its name as UI text in the scene.

Para criar a classe FaceAnalysis :To create the FaceAnalysis class:

  1. Clique com o botão direito do mouse na pasta ativos , localizada no painel projeto, e clique em criar > pasta.Right-click in the Assets Folder located in the Project Panel, then click on Create > Folder. Chame os scriptsda pasta.Call the folder Scripts.

    Crie a classe FaceAnalysis.

  2. Clique duas vezes na pasta recém-criada para abri-la.Double click on the folder just created, to open it.

  3. Clique com o botão direito do mouse dentro da pasta e clique em criar > C# script.Right-click inside the folder, then click on Create > C# Script. Chame o script FaceAnalysis.Call the script FaceAnalysis.

  4. Clique duas vezes no novo script FaceAnalysis para abri-lo com o Visual Studio 2017.Double click on the new FaceAnalysis script to open it with Visual Studio 2017.

  5. Insira os seguintes namespaces acima da 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. Agora você precisa adicionar todos os objetos que são usados para deserialising.You now need to add all of the objects which are used for deserialising. Esses objetos precisam ser adicionados fora do script FaceAnalysis (abaixo da chave inferior).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. Os métodos Start () e Update () não serão usados, portanto, exclua-os agora.The Start() and Update() methods will not be used, so delete them now.

  8. Dentro da classe FaceAnalysis , adicione as seguintes variáveis: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 -";
    

    Observação

    Substitua a chave e o PersonGroupId pela sua chave de serviço e a ID do grupo que você criou anteriormente.Replace the key and the personGroupId with your Service Key and the Id of the group that you created previously.

  9. Adicione o método ativo () , que initialises a classe, adicionando a classe ImageCapture à câmera principal e chama o método de criação de rótulo: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. Adicione o método CreateLabel () , que cria o objeto Label para exibir o resultado da análise: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. Adicione o método DetectFacesFromImage () e GetImageAsByteArray () .Add the DetectFacesFromImage() and GetImageAsByteArray() method. O primeiro solicitará que o serviço de reconhecimento facial detecte qualquer face possível na imagem enviada, enquanto o último é necessário para converter a imagem capturada em uma matriz de bytes: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. Adicione o método IdentifyFaces () , que solicita que o serviço de reconhecimento facial identifique qualquer face conhecida detectada anteriormente na imagem enviada.Add the IdentifyFaces() method, which requests the Face Recognition Service to identify any known face previously detected in the submitted image. A solicitação retornará uma ID da pessoa identificada, mas não o nome: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. Adicione o método GetPerson () .Add the GetPerson() method. Ao fornecer a ID Person, esse método solicita que o serviço de reconhecimento facial retorne o nome da pessoa identificada: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. Lembre-se de salvar as alterações antes de voltar para o editor do Unity.Remember to Save the changes before going back to the Unity Editor.

  15. No editor do Unity, arraste o script FaceAnalysis da pasta scripts no painel projeto para o objeto da câmera principal no painel hierarquia.In the Unity Editor, drag the FaceAnalysis script from the Scripts folder in Project panel to the Main Camera object in the Hierarchy panel. O novo componente de script será tão adicionado à câmera principal.The new script component will be so added to the Main Camera.

Coloque FaceAnalysis na câmera principal

Capítulo 7-criar a classe ImageCaptureChapter 7 - Create the ImageCapture class

A finalidade da classe ImageCapture é hospedar os métodos necessários para se comunicar com o serviço de reconhecimento de face do Azure para analisar a imagem que será capturada, identificando as faces e determinando se ela pertence a uma pessoa conhecida.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. Se uma pessoa conhecida for encontrada, essa classe exibirá seu nome como texto da interface do usuário na cena.If a known person is found, this class will display its name as UI text in the scene.

Para criar a classe ImageCapture :To create the ImageCapture class:

  1. Clique com o botão direito do mouse na pasta scripts que você criou anteriormente e, em seguida, clique em criar, C# script.Right-click inside the Scripts folder you have created previously, then click on Create, C# Script. Chame o script ImageCapture.Call the script ImageCapture.

  2. Clique duas vezes no novo script ImageCapture para abri-lo com o Visual Studio 2017.Double click on the new ImageCapture script to open it with Visual Studio 2017.

  3. Insira os seguintes namespaces acima da 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. Dentro da classe ImageCapture , adicione as seguintes variáveis: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. Adicione os métodos ativo () e Iniciar () necessários para inicializar a classe e permitir que o HoloLens capture os gestos do usuário: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. Adicione o TapHandler () que é chamado quando o usuário executa um gesto de toque :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. Adicione o método ExecuteImageCaptureAndAnalysis () , que iniciará o processo de captura de imagem: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. Adicione os manipuladores que são chamados quando o processo de captura de foto foi concluído: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. Lembre-se de salvar as alterações antes de voltar para o editor do Unity.Remember to Save the changes before going back to the Unity Editor.

Capítulo 8-criando a soluçãoChapter 8 - Building the solution

Para executar um teste completo de seu aplicativo, você precisará Sideload-lo no seu HoloLens.To perform a thorough test of your application you will need to sideload it onto your HoloLens.

Antes de fazer isso, verifique se:Before you do, ensure that:

  • Todas as configurações mencionadas no capítulo 3 estão definidas corretamente.All the settings mentioned in the Chapter 3 are set correctly.
  • O script FaceAnalysis é anexado ao objeto da câmera principal.The script FaceAnalysis is attached to the Main Camera object.
  • A chave de autenticação e a ID do grupo foram definidas no script FaceAnalysis .Both the Auth Key and Group Id have been set within the FaceAnalysis script.

R neste ponto você está pronto para criar a solução.A this point you are ready to build the Solution. Depois que a solução tiver sido criada, você estará pronto para implantar seu aplicativo.Once the Solution has been built, you will be ready to deploy your application.

Para iniciar o processo de compilação:To begin the Build process:

  1. Salve a cena atual clicando em arquivo, salvar.Save the current scene by clicking on File, Save.

  2. Vá para arquivo, configurações de compilação, clique em Adicionar cenas de abertura.Go to File, Build Settings, click on Add Open Scenes.

  3. Certifique-se de que C# os projetos de Unity em escala.Make sure to tick Unity C# Projects.

    Implante a solução do Visual Studio.

  4. Pressione compilar.Press Build. Ao fazer isso, o Unity iniciará uma janela Explorador de arquivos, onde você precisará criar e, em seguida, selecionar uma pasta na qual o aplicativo será compilado.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. Crie essa pasta agora, dentro do projeto do Unity, e chame-a de App.Create that folder now, within the Unity project, and call it App. Em seguida, com a pasta de aplicativo selecionada, pressione Selecionar pasta.Then with the App folder selected, press Select Folder.

  5. O Unity começará a compilar seu projeto, na pasta do aplicativo.Unity will begin building your project, out to the App folder.

  6. Depois que o Unity terminar a compilação (pode levar algum tempo), ele abrirá uma janela do explorador de arquivos no local de sua compilação.Once Unity has finished building (it might take some time), it will open a File Explorer window at the location of your build.

    Implante a solução do Visual Studio.

  7. Abra a pasta do aplicativo e, em seguida, abra a nova solução de projeto (como visto acima, MR_FaceRecognition. sln).Open your App folder, and then open the new Project Solution (as seen above, MR_FaceRecognition.sln).

Capítulo 9-implantando seu aplicativoChapter 9 - Deploying your application

Para implantar no HoloLens:To deploy on HoloLens:

  1. Você precisará do endereço IP do seu HoloLens (para implantação remota) e para garantir que seu HoloLens esteja no modo de desenvolvedor.You will need the IP Address of your HoloLens (for Remote Deploy), and to ensure your HoloLens is in Developer Mode. Para fazer isso:To do this:

    1. Enquanto estiver desgastando seu HoloLens, abra as configurações.Whilst wearing your HoloLens, open the Settings.
    2. Acessar Opções de rede & Internet > Wi-Fi > avançadoGo to Network & Internet > Wi-Fi > Advanced Options
    3. Anote o endereço IPv4 .Note the IPv4 address.
    4. Em seguida, navegue de volta para configuraçõese, em seguida, atualize & > de segurança para desenvolvedoresNext, navigate back to Settings, and then to Update & Security > For Developers
    5. Defina o modo de desenvolvedor em.Set Developer Mode On.
  2. Navegue até sua nova compilação do Unity (a pasta do aplicativo ) e abra o arquivo de solução com o Visual Studio.Navigate to your new Unity build (the App folder) and open the solution file with Visual Studio.

  3. Na configuração da solução, selecione depurar.In the Solution Configuration select Debug.

  4. Na plataforma da solução, selecione x86, computador remoto.In the Solution Platform, select x86, Remote Machine.

    Implante a solução do Visual Studio.

  5. Vá para o menu Compilar e clique em implantar soluçãopara Sideload o aplicativo ao seu HoloLens.Go to the Build menu and click on Deploy Solution, to sideload the application to your HoloLens.

  6. Seu aplicativo agora deve aparecer na lista de aplicativos instalados em seu HoloLens, pronto para ser iniciado!Your App should now appear in the list of installed apps on your HoloLens, ready to be launched!

Observação

Para implantar em headsets de imersão, defina a plataforma da solução como computador locale defina a configuração a ser depurada, com x86 como a plataforma.To deploy to immersive headset, set the Solution Platform to Local Machine, and set the Configuration to Debug, with x86 as the Platform. Em seguida, implante no computador local, usando o menu Compilar, selecionando implantar solução.Then deploy to the local machine, using the Build menu, selecting Deploy Solution.

Capítulo 10-usando o aplicativoChapter 10 - Using the application

  1. Desgastando o HoloLens, inicie o aplicativo.Wearing the HoloLens, launch the app.

  2. Examine a pessoa que você registrou com o API de detecção facial.Look at the person that you have registered with the Face API. Certifique-se de que:Make sure that:

    • A face da pessoa não está muito distante e claramente visívelThe person's face is not too distant and clearly visible
    • A iluminação do ambiente não é muito escuraThe environment lighting is not too dark
  3. Use o gesto de toque para capturar a imagem da pessoa.Use the tap gesture to capture the person's picture.

  4. Aguarde até que o aplicativo envie a solicitação de análise e receba uma resposta.Wait for the App to send the analysis request and receive a response.

  5. Se a pessoa tiver sido reconhecida com êxito, o nome da pessoa aparecerá como texto da interface do usuário.If the person has been successfully recognized, the person's name will appear as UI text.

  6. Você pode repetir o processo de captura usando o gesto de toque a cada poucos segundos.You can repeat the capture process using the tap gesture every few seconds.

Seu aplicativo de API de Detecção Facial do Azure concluídoYour finished Azure Face API Application

Parabéns, você criou um aplicativo de realidade misturada que aproveita o serviço de reconhecimento de face do Azure para detectar rostos em uma imagem e identificar quaisquer faces conhecidas.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.

resultado da conclusão deste curso

Exercícios de bônusBonus exercises

Exercício 1Exercise 1

A API de detecção facial do Azure é eficiente o suficiente para detectar até 64 rostos em uma única imagem.The Azure Face API is powerful enough to detect up to 64 faces in a single image. Estenda o aplicativo para que ele possa reconhecer duas ou três faces, entre muitas outras pessoas.Extend the application, so that it could recognize two or three faces, amongst many other people.

Exercício 2Exercise 2

O API de detecção facial do Azure também é capaz de fornecer de volta todos os tipos de informações de atributo.The Azure Face API is also able to provide back all kinds of attribute information. Integre-o ao aplicativo.Integrate this into the application. Isso pode ser ainda mais interessante, quando combinado com o API de detecção de emoções.This could be even more interesting, when combined with the Emotion API.