HoloLens (1.ª generación) y Azure 304: Reconocimiento facial
Nota:
Los tutoriales de Mixed Reality Academy se han diseñado teniendo en cuenta HoloLens (1.ª generación) y los cascos envolventes de realidad mixta. Por lo tanto, creemos que es importante conservar estos tutoriales para los desarrolladores que sigan buscando instrucciones sobre el desarrollo para esos dispositivos. Estos tutoriales no se actualizarán con los conjuntos de herramientas o las interacciones más recientes que se usan para HoloLens 2. Se mantendrán para que sigan funcionando en los dispositivos compatibles. Habrá una nueva serie de tutoriales que se publicarán en el futuro que demostrarán cómo desarrollar para HoloLens 2. Este aviso se actualizará con un vínculo a esos tutoriales cuando se publiquen.
En este curso aprenderá a agregar funcionalidades de reconocimiento facial a una aplicación de realidad mixta, mediante Azure Cognitive Services, con Microsoft Face API.
Azure Face API es un servicio de Microsoft, que proporciona a los desarrolladores los algoritmos de cara más avanzados, todos en la nube. Face API tiene dos funciones principales: detección de caras con atributos y reconocimiento facial. Esto permite a los desarrolladores establecer simplemente un conjunto de grupos para caras y, a continuación, enviar imágenes de consulta al servicio más adelante, para determinar a quién pertenece una cara. Para más información, visite la página Azure Face Recognition.
Después de completar este curso, tendrá una aplicación holoLens de realidad mixta, que podrá hacer lo siguiente:
- Usa un gesto de pulsación para iniciar la captura de una imagen mediante la cámara HoloLens incorporada.
- Envíe la imagen capturada al servicio Azure Face API .
- Reciba los resultados del algoritmo de Face API .
- Use una interfaz de usuario sencilla para mostrar el nombre de las personas coincidentes.
Esto le enseñará a obtener los resultados del servicio Face API en la aplicación de realidad mixta basada en Unity.
En la aplicación, es el momento de integrar los resultados con el diseño. Este curso está diseñado para enseñar a integrar un servicio de Azure con el proyecto de Unity. Es su trabajo usar el conocimiento que obtiene de este curso para mejorar la aplicación de realidad mixta.
Compatibilidad con dispositivos
| Curso | HoloLens | Cascos envolventes |
|---|---|---|
| MR y Azure 304: Reconocimiento facial | ✔️ | ✔️ |
Nota:
Aunque este curso se centra principalmente en HoloLens, también puede aplicar lo que aprende en este curso a cascos envolventes de Windows Mixed Reality (VR). Dado que los cascos envolventes (VR) no tienen cámaras accesibles, necesitará una cámara externa conectada a su PC. A medida que siga con el curso, verá notas sobre los cambios que podría necesitar para admitir cascos envolventes (VR).
Requisitos previos
Nota:
Este tutorial está diseñado para desarrolladores que tienen experiencia básica con Unity y C#. Tenga en cuenta también que los requisitos previos y las instrucciones escritas de este documento representan lo que se ha probado y comprobado en el momento de redactarlo (mayo de 2018). Puede usar el software más reciente, como se muestra en el artículo de instalación de las herramientas , aunque no debe asumirse que la información de este curso coincidirá perfectamente con lo que encontrará en el software más reciente que lo que se muestra a continuación.
Se recomienda el siguiente hardware y software para este curso:
- Un equipo de desarrollo, compatible con Windows Mixed Reality para el desarrollo de cascos envolventes (VR)
- Windows 10 Fall Creators Update (o posterior) con el modo desarrollador habilitado
- El SDK de Windows 10 más reciente
- Unity 2017.4
- Visual Studio 2017
- Casco envolvente (VR) de Windows Mixed Reality o Microsoft HoloLens con el modo desarrollador habilitado
- Una cámara conectada a su PC (para el desarrollo de cascos envolventes)
- Acceso a Internet para la configuración de Azure y recuperación de Face API
Antes de comenzar
- Para evitar encontrar problemas al compilar este proyecto, se recomienda encarecidamente crear el proyecto mencionado en este tutorial en una carpeta raíz o casi raíz (las rutas de acceso de carpeta largas pueden causar problemas en tiempo de compilación).
- Configure y pruebe holoLens. Si necesita compatibilidad con la configuración de HoloLens, asegúrese de visitar el artículo configuración de HoloLens.
- Es una buena idea realizar calibración y ajuste del sensor al empezar a desarrollar una nueva aplicación de HoloLens (a veces puede ayudar a realizar esas tareas para cada usuario).
Para obtener ayuda sobre calibración, siga este vínculo al artículo Calibración de HoloLens.
Para obtener ayuda sobre la optimización del sensor, siga este vínculo al artículo Optimización de sensores de HoloLens.
Capítulo 1: Azure Portal
Para usar el servicio Face API en Azure, deberá configurar una instancia del servicio para que esté disponible para la aplicación.
En primer lugar, inicie sesión en Azure Portal.
Nota:
Si aún no tiene una cuenta de Azure, deberá crear una. Si sigue este tutorial en una situación de clase o laboratorio, pida a su instructor o a uno de los proctores que le ayuden a configurar la nueva cuenta.
Una vez que haya iniciado sesión, haga clic en Nuevo en la esquina superior izquierda y busque Face API, presione Entrar.
Nota:
Es posible que la palabra New se haya reemplazado por Create a resource (Crear un recurso) en portales más recientes.
La nueva página proporcionará una descripción del servicio Face API . En la parte inferior izquierda de este símbolo del sistema, seleccione el botón Crear para crear una asociación con este servicio.
Una vez que haya hecho clic en Crear:
Inserte el nombre deseado para esta instancia de servicio.
Seleccione una suscripción.
Seleccione el plan de tarifa adecuado para usted, si es la primera vez que se crea un servicio Face API, debería estar disponible un nivel gratuito (denominado F0).
Elija un grupo de recursos o cree uno nuevo. Un grupo de recursos proporciona una manera de supervisar, controlar el acceso, aprovisionar y administrar la facturación de una colección de recursos de Azure. Se recomienda mantener todos los servicios de Azure asociados a un único proyecto (por ejemplo, estos laboratorios) en un grupo de recursos común).
Si desea obtener más información sobre los grupos de recursos de Azure, visite el artículo sobre el grupo de recursos.
La aplicación para UWP, Person Maker, que usas más adelante, requiere el uso de "Oeste de EE. UU." para la ubicación.
También deberá confirmar que ha comprendido los Términos y Condiciones aplicados a este Servicio.
Seleccione Crear*.
Una vez que haya hecho clic en Crear,* tendrá que esperar a que se cree el servicio, esto puede tardar un minuto.
Aparecerá una notificación en el portal una vez creada la instancia de servicio.
Haga clic en las notificaciones para explorar la nueva instancia de servicio.
Cuando esté listo, haga clic en el botón Ir al recurso en la notificación para explorar la nueva instancia de servicio.
En este tutorial, la aplicación tendrá que realizar llamadas al servicio, que se realiza a través del uso de la suscripción del servicio "clave". En la página Inicio rápido, del servicio Face API , el primer punto es el número 1, para Obtener las claves.
En la página Servicio, seleccione el hipervínculo Claves azules (si está en la página Inicio rápido) o el vínculo Claves del menú de navegación de servicios (a la izquierda, indicado por el icono "clave", para mostrar las claves).
Nota:
Tome nota de cualquiera de las claves y protésela, ya que la necesitará más adelante.
Capítulo 2: Uso de la aplicación para UWP "Person Maker"
Asegúrate de descargar la aplicación para UWP precompilada llamada Person Maker. Esta aplicación no es el producto final de este curso, solo una herramienta para ayudarle a crear las entradas de Azure, que el proyecto posterior confiará.
Person Maker permite crear entradas de Azure, que están asociadas a personas y grupos de personas. La aplicación colocará toda la información necesaria en un formato que, a continuación, puede ser utilizado por FaceAPI, con el fin de reconocer las caras de las personas que ha agregado.
[IMPORTANTE] Person Maker usa algunas limitaciones básicas para garantizar que no supere el número de llamadas de servicio por minuto para el nivel de suscripción gratuita. El texto verde de la parte superior cambiará a rojo y se actualizará como "ACTIVO" cuando se produzca la limitación; Si este es el caso, basta con esperar a la aplicación (esperará hasta que pueda continuar accediendo al servicio face, actualizando como "IN-ACTIVE" cuando pueda usarlo de nuevo).
Esta aplicación usa las bibliotecas Microsoft.ProjectOxford.Face , que le permitirán hacer uso completo de Face API. Esta biblioteca está disponible de forma gratuita como paquete NuGet. Para obtener más información sobre esto y otras API similares, asegúrese de visitar el artículo de referencia de API.
Nota:
Estos son solo los pasos necesarios, las instrucciones sobre cómo realizar estas tareas están más abajo en el documento. La aplicación Person Maker le permitirá:
Cree un grupo de personas, que es un grupo compuesto por varias personas a las que desea asociar. Con su cuenta de Azure, puede hospedar varios grupos de personas.
Cree una persona, que es miembro de un grupo de personas. Cada persona tiene una serie de imágenes de Face asociadas.
Asigne imágenes de caras a una persona para permitir que el servicio Azure Face API reconozca una persona por la cara correspondiente.
Entrenamiento del servicio Azure Face API.
Ten en cuenta, así que para entrenar esta aplicación para reconocer a las personas, necesitarás diez (10) fotos de primer plano de cada persona que quieras agregar a tu grupo de personas. La aplicación Cam de Windows 10 puede ayudarte a llevarlas. Debe asegurarse de que cada foto sea clara (evite desenfoque, ocultación o estar demasiado lejos del asunto), tener la foto en formato de archivo jpg o png, con el tamaño del archivo de imagen que no sea mayor de 4 MB y no menos de 1 KB.
Nota:
Si sigue este tutorial, no use su propia cara para el entrenamiento, ya que cuando coloca HoloLens en, no puede mirarse a sí mismo. Use la cara de un compañero o estudiante.
Ejecución de Person Maker:
Abra la carpeta PersonMaker y haga doble clic en la solución PersonMaker para abrirla con Visual Studio.
Una vez abierta la solución PersonMaker, asegúrese de que:
La configuración de la solución se establece en Depurar.
La plataforma de soluciones está establecida en x86.
La plataforma de destino es máquina local.
También es posible que tenga que restaurar paquetes NuGet (haga clic con el botón derecho en la solución y seleccione Restaurar paquetes NuGet).
Haga clic en Equipo local y se iniciará la aplicación. Tenga en cuenta que, en pantallas más pequeñas, es posible que todo el contenido no esté visible, aunque puede desplazarse más hacia abajo para verlo.
Inserte la clave de autenticación de Azure, que debe tener, desde el servicio Face API en Azure.
Insertar:
- Identificador que desea asignar al grupo de personas. El identificador debe estar en minúsculas, sin espacios. Tome nota de este identificador, ya que será necesario más adelante en el proyecto de Unity.
- Nombre que desea asignar al grupo de personas (puede tener espacios).
Presione el botón Crear grupo de personas. Debe aparecer un mensaje de confirmación debajo del botón.
Nota:
Si tiene un error de "Acceso denegado", compruebe la ubicación establecida para el servicio de Azure. Como se indicó anteriormente, esta aplicación está diseñada para "Oeste de EE. UU.".
Importante
Observará que también puede hacer clic en el botón Capturar un grupo conocido: esto es para si ya ha creado un grupo de personas y desea usarlo, en lugar de crear uno nuevo. Tenga en cuenta que, si hace clic en Crear un grupo de personas con un grupo conocido, también capturará un grupo.
Inserte el nombre de la persona que desea crear.
Haga clic en el botón Crear persona .
Debe aparecer un mensaje de confirmación debajo del botón.
Si desea eliminar una persona que ha creado anteriormente, puede escribir el nombre en el cuadro de texto y presionar Eliminar persona.
Asegúrese de que conoce la ubicación de diez (10) fotos de la persona que desea agregar a su grupo.
Presione Crear y abrir carpeta para abrir el Explorador de Windows en la carpeta asociada a la persona. Agregue las diez (10) imágenes en la carpeta . Deben ser de formato de archivo JPG o PNG .
Haga clic en Enviar a Azure. Un contador le mostrará el estado del envío, seguido de un mensaje cuando se haya completado.
Una vez finalizado el contador y se ha mostrado un mensaje de confirmación, haga clic en Entrenar para entrenar el servicio.
Una vez completado el proceso, está listo para pasar a Unity.
Capítulo 3: Configuración del proyecto de Unity
A continuación se muestra una configuración típica para desarrollar con realidad mixta y, como tal, es una buena plantilla para otros proyectos.
Abra Unity y haga clic en Nuevo.
Ahora deberá proporcionar un nombre de proyecto de Unity. Insertar MR_FaceRecognition. Asegúrese de que el tipo de proyecto esté establecido en 3D. Establezca la ubicación en algún lugar adecuado para usted (recuerde que más cerca de los directorios raíz es mejor). A continuación, haga clic en Crear proyecto.
Con Unity abierto, vale la pena comprobar que el Editor de scripts predeterminado está establecido en Visual Studio. Vaya a Editar > preferencias y, a continuación, en la nueva ventana, vaya a Herramientas externas. Cambie el Editor de scripts externos a Visual Studio 2017. Cierre la ventana Preferencias.
A continuación, vaya a Configuración > de compilación de archivos y cambie la plataforma a Plataforma universal de Windows haciendo clic en el botón Cambiar plataforma.
Vaya a Configuración de compilación de archivos > y asegúrese de que:
El dispositivo de destino está establecido en HoloLens
Para los cascos envolventes, establezca Dispositivo de destino en Cualquier dispositivo.
Tipo de compilación se establece en D3D
El SDK se establece en Latest installed (Versión más reciente instalada)
La versión de Visual Studio se establece en Latest installed (Versión más reciente instalada)
Build and Run (Compilar y ejecutar ) está establecido en Equipo local
Guarde la escena y agréguela a la compilación.
Para ello, seleccione Agregar escenas abiertas. Aparecerá una ventana de guardado.
Seleccione el botón Nueva carpeta para crear una carpeta y asígnela el nombre Scenes.
Abra la carpeta Escenas recién creada y, a continuación, en el campo Nombre de archivo: texto, escriba FaceRecScene y presione Guardar.
La configuración restante, en Configuración de compilación, debe dejarse como predeterminada por ahora.
En la ventana Configuración de compilación, haga clic en el botón Configuración del reproductor; se abrirá el panel relacionado en el espacio donde se encuentra el Inspector.
En este panel, es necesario comprobar algunos valores:
En la pestaña Otros valores :
La versión del entorno de ejecución de scripting debe ser experimental (equivalente a .NET 4.6). Al cambiar esto, se desencadenará la necesidad de reiniciar el Editor.
El back-end de scripting debe ser .NET
El nivel de compatibilidad de API debe ser .NET 4.6
En la pestaña Configuración de publicación, en Funcionalidades, active:
InternetClient
Cámara web
Más abajo en el panel, en Configuración de XR (que se encuentra a continuación de Configuración de publicación), marque Virtual Reality Supported (Compatible con la realidad virtual), asegúrese de que se agrega el SDK de Windows Mixed Reality.
De nuevo en Configuración de compilación, los proyectos de C# de Unity ya no están atenuados; marque la casilla situada junto a esto.
Cierre la ventana Build Settings (Configuración de compilación).
Guarde la escena y el proyecto (FILE > SAVE SCENE /FILE > SAVE PROJECT).
Capítulo 4: Configuración de la cámara principal
Importante
Si desea omitir el componente Configuración de Unity de este curso y continuar directamente en el código, no dude en descargar este paquete .unitypackage e importarlo en el proyecto como un paquete personalizado. Tenga en cuenta que este paquete también incluye la importación de la DLL newtonsoft, que se trata en el capítulo 5. Con esta importación, puede continuar desde el capítulo 6.
En el Panel jerarquía , seleccione la cámara principal.
Una vez seleccionado, podrá ver todos los componentes de la cámara principal en el panel inspector.
El objeto Camera debe denominarse Cámara principal (tenga en cuenta la ortografía).
La etiqueta de cámara principal debe establecerse en MainCamera (tenga en cuenta la ortografía).
Asegúrese de que la posición de transformación está establecida en 0, 0, 0
Establecer borrar marcas en color sólido
Establezca el color de fondo del componente de cámara en Negro, Alfa 0 (Código hexadecimal: #00000000)
Capítulo 5: Importación de la biblioteca Newtonsoft.Json
Importante
Si importó el archivo '.unitypackage' en el último capítulo, puede omitir este capítulo.
Para ayudarle a deserializar y serializar objetos recibidos y enviados a Bot Service, debe descargar la biblioteca Newtonsoft.Json . Encontrará una versión compatible ya organizada con la estructura de carpetas de Unity correcta en este archivo de paquete de Unity.
Para importar la biblioteca:
Descargue el paquete de Unity.
Haga clic en Activos, Importar paquete, Paquete personalizado.
Busque el paquete de Unity que ha descargado y haga clic en Abrir.
Asegúrese de que todos los componentes del paquete están marcados y haga clic en Importar.
Capítulo 6: Creación de la clase FaceAnalysis
El propósito de la clase FaceAnalysis es hospedar los métodos necesarios para comunicarse con azure Face Recognition Service.
- Después de enviar el servicio una imagen de captura, la analizará e identificará las caras dentro y determinará si alguna pertenece a una persona conocida.
- Si se encuentra una persona conocida, esta clase mostrará su nombre como texto de la interfaz de usuario en la escena.
Para crear la clase FaceAnalysis :
Haga clic con el botón derecho en la carpeta Assets que se encuentra en el Panel del proyecto y, a continuación, haga clic en Crear>carpeta. Llame a la carpeta Scripts.
Haga doble clic en la carpeta que acaba de crear para abrirla.
Haga clic con el botón derecho en la carpeta y, a continuación, haga clic en Crear>script de C#. Llame al script FaceAnalysis.
Haga doble clic en el nuevo script FaceAnalysis para abrirlo con Visual Studio 2017.
Escriba los siguientes espacios de nombres encima de la clase FaceAnalysis :
using Newtonsoft.Json; using System.Collections; using System.Collections.Generic; using System.IO; using System.Text; using UnityEngine; using UnityEngine.Networking;Ahora debe agregar todos los objetos que se usan para deserializar. Estos objetos deben agregarse fuera del script FaceAnalysis (debajo del corchete inferior).
/// <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; } }Los métodos Start() y Update() no se usarán, por lo que eliminarlos ahora.
Dentro de la clase FaceAnalysis , agregue las siguientes 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 -";Nota:
Reemplace la clave y personGroupId por la clave de servicio y el identificador del grupo que creó anteriormente.
Agregue el método Awake(), que inicializa la clase , agregando la clase ImageCapture a la cámara principal y llama al método de creación Label:
/// <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(); }Agregue el método CreateLabel(), que crea el objeto Label para mostrar el resultado del análisis:
/// <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 = "."; }Agregue el método DetectFacesFromImage() y GetImageAsByteArray(). El primero solicitará al Servicio de reconocimiento facial para detectar cualquier cara posible en la imagen enviada, mientras que esta última es necesaria para convertir la imagen capturada en una matriz de bytes:
/// <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); }Agregue el método IdentifyFaces(), que solicita al Servicio de reconocimiento facial que identifique cualquier cara conocida detectada anteriormente en la imagen enviada. La solicitud devolverá un identificador de la persona identificada, pero no el nombre:
/// <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); } } }Agregue el método GetPerson(). Al proporcionar el identificador de persona, este método solicita a Face Recognition Service que devuelva el nombre de la persona identificada:
/// <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; } }Recuerde Guardar los cambios antes de volver al Editor de Unity.
En el Editor de Unity, arrastre el script FaceAnalysis desde la carpeta Scripts del panel Proyecto al objeto Cámara principal en el panel Jerarquía. El nuevo componente de script se agregará a la cámara principal.
Capítulo 7: Creación de la clase ImageCapture
El propósito de la clase ImageCapture es hospedar los métodos necesarios para comunicarse con azure Face Recognition Service para analizar la imagen que va a capturar, identificar caras en ella y determinar si pertenece a una persona conocida. Si se encuentra una persona conocida, esta clase mostrará su nombre como texto de la interfaz de usuario en la escena.
Para crear la clase ImageCapture :
Haga clic con el botón derecho en la carpeta Scripts que ha creado anteriormente y, a continuación, haga clic en Crear, Script de C#. Llame al script ImageCapture.
Haga doble clic en el nuevo script ImageCapture para abrirlo con Visual Studio 2017.
Escriba los siguientes espacios de nombres encima de la clase ImageCapture:
using System.IO; using System.Linq; using UnityEngine; using UnityEngine.XR.WSA.Input; using UnityEngine.XR.WSA.WebCam;Dentro de la clase ImageCapture , agregue las siguientes 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;Agregue los métodos Awake() e Start() necesarios para inicializar la clase y permitir que HoloLens capture los gestos del usuario:
/// <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(); }Agregue tapHandler () al que se llama cuando el usuario realiza un gesto de pulsación :
/// <summary> /// Respond to Tap Input. /// </summary> private void TapHandler(TappedEventArgs obj) { tapsCount++; ExecuteImageCaptureAndAnalysis(); }Agregue el método ExecuteImageCaptureAndAnalysis(), que comenzará el proceso de captura de imágenes:
/// <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); }); }); }Agregue los controladores a los que se llama cuando se haya completado el proceso de captura de fotos:
/// <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()); }Recuerde Guardar los cambios antes de volver al Editor de Unity.
Capítulo 8: Creación de la solución
Para realizar una prueba exhaustiva de la aplicación, deberá transferirla localmente a HoloLens.
Antes de hacerlo, asegúrese de que:
- Todas las configuraciones mencionadas en el capítulo 3 se establecen correctamente.
- El script FaceAnalysis se adjunta al objeto Main Camera.
- Tanto la clave de autenticación como el identificador de grupo se han establecido en el script FaceAnalysis.
Un punto que está listo para compilar la solución. Una vez compilada la solución, estará listo para implementar la aplicación.
Para comenzar el proceso de compilación:
Guarde la escena actual haciendo clic en Archivo, Guardar.
Vaya a Archivo, Configuración de compilación, haga clic en Agregar escenas abiertas.
Asegúrese de marcar Proyectos de C# de Unity.
Presione Compilar. Al hacerlo, Unity iniciará una ventana de Explorador de archivos, donde debe crear y, a continuación, seleccionará una carpeta para compilar la aplicación. Cree esa carpeta ahora, en el proyecto de Unity y llámela Aplicación. A continuación, con la carpeta Aplicación seleccionada, presione Seleccionar carpeta.
Unity comenzará a compilar el proyecto, en la carpeta Aplicación.
Una vez que Unity haya terminado de compilar (puede tardar algún tiempo), se abrirá una ventana de Explorador de archivos en la ubicación de la compilación.
Abra la carpeta Aplicación y, a continuación, abra la nueva solución de proyecto (como se ha visto anteriormente, MR_FaceRecognition.sln).
Capítulo 9: Implementación de la aplicación
Para realizar la implementación en HoloLens:
Necesitará la dirección IP de HoloLens (para la implementación remota) y para asegurarse de que HoloLens está en modo de desarrollador. Para ello, siga estos pasos:
- Mientras llevas tu HoloLens, abre la configuración.
- Vaya a Opciones avanzadas de Red e Internet > Wi-Fi >
- Anote la dirección IPv4 .
- A continuación, vuelva a Configuración y, a continuación, a Actualizar y seguridad > para desarrolladores.
- Establezca el modo de desarrollador activado.
Vaya a la nueva compilación de Unity (la carpeta Aplicación ) y abra el archivo de solución con Visual Studio.
En Configuración de la solución, seleccione Depurar.
En la Plataforma de soluciones, seleccione x86, Máquina remota.
Vaya al menú Compilar y haga clic en Implementar solución para transferir localmente la aplicación a HoloLens.
La aplicación debería aparecer ahora en la lista de aplicaciones instaladas en HoloLens, lista para iniciarse.
Nota:
Para realizar la implementación en cascos envolventes, establezca la Plataforma de soluciones en Máquina local y establezca la configuración en Depurar, con x86 como plataforma. A continuación, implemente en el equipo local mediante el menú Compilar y seleccione Implementar solución.
Capítulo 10: Uso de la aplicación
Con HoloLens, inicie la aplicación.
Examine la persona que ha registrado con Face API. Compruebe los siguiente:
- La cara de la persona no está demasiado distante y claramente visible
- La iluminación del entorno no es demasiado oscura
Use el gesto de pulsación para capturar la imagen de la persona.
Espere a que la aplicación envíe la solicitud de análisis y reciba una respuesta.
Si la persona se ha reconocido correctamente, el nombre de la persona aparecerá como texto de la interfaz de usuario.
Puede repetir el proceso de captura mediante el gesto de pulsación cada pocos segundos.
Aplicación de Azure Face API finalizada
Enhorabuena, ha creado una aplicación de realidad mixta que aprovecha el servicio Azure Face Recognition para detectar caras dentro de una imagen e identificar las caras conocidas.
Ejercicios extra
Ejercicio 1
Azure Face API es lo suficientemente eficaz como para detectar hasta 64 caras en una sola imagen. Amplíe la aplicación para que pueda reconocer dos o tres caras, entre muchas otras personas.
Ejercicio 2
Azure Face API también puede proporcionar todo tipo de información de atributo. Integrarlo en la aplicación. Esto podría ser aún más interesante, cuando se combina con Emotion API.