Inicio rápido: Detección de caras en una imagen mediante Face REST API y C#Quickstart: Detect faces in an image using the Face REST API and C#

En esta guía de inicio rápido, usará la API REST de Azure Face con C# para detectar caras humanas en una imagen.In this quickstart, you will use the Azure Face REST API with C# to detect human faces in an image.

Si no tiene una suscripción a Azure, cree una cuenta gratuita antes de empezar.If you don't have an Azure subscription, create a free account before you begin.

Requisitos previosPrerequisites

Creación del proyecto de Visual StudioCreate the Visual Studio project

  1. En Visual Studio, cree un nuevo proyecto de Aplicación de consola (.NET Framework) y asígnele el nombre FaceDetection.In Visual Studio, create a new Console app (.NET Framework) project and name it FaceDetection.
  2. Si hay otros proyectos en la solución, seleccione este como proyecto de inicio único.If there are other projects in your solution, select this one as the single startup project.

Adición del código de detección de carasAdd face detection code

Abra el archivo Program.cs del nuevo proyecto.Open the new project's Program.cs file. Aquí, agregará el código necesario para cargar imágenes y detectar caras.Here, you will add the code needed to load images and detect faces.

Inclusión de espacios de nombresInclude namespaces

Agregue las siguientes instrucciones using al principio del archivo Program.cs.Add the following using statements to the top of your Program.cs file.

using System;
using System.IO;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;

Adición de los campos esencialesAdd essential fields

Agregue la clase Program que contiene los campos siguientes.Add the Program class containing the following fields. Estos datos especifican cómo conectarse al servicio Face y dónde obtener los datos de entrada.This data specifies how to connect to the Face service and where to get the input data. Deberá actualizar el campo subscriptionKey con el valor de la clave de suscripción y es posible que deba cambiar la cadena uriBase para que contenga el identificador de la región correcta (consulte la documentación de Face API para obtener una lista de los puntos de conexión de todas las regiones).You'll need to update the subscriptionKey field with the value of your subscription key, and you may need to change the uriBase string so that it contains the correct region identifier (see the Face API docs for a list of all region endpoints).

namespace DetectFace
{
    class Program
    {

        // Replace <Subscription Key> with your valid subscription key.
        const string subscriptionKey = "<Subscription Key>";

        // NOTE: You must use the same region in your REST call as you used to
        // obtain your subscription keys. For example, if you obtained your
        // subscription keys from westus, replace "westcentralus" in the URL
        // below with "westus".
        //
        // Free trial subscription keys are generated in the "westus" region.
        // If you use a free trial subscription key, you shouldn't need to change
        // this region.
        const string uriBase =
            "https://westcentralus.api.cognitive.microsoft.com/face/v1.0/detect";

Recepción de entradas de imagenReceive image input

Agregue el siguiente código al método Main de la clase Program.Add the following code to the Main method of the Program class. Este código escribe un mensaje en la consola que pide al usuario que escriba una dirección URL de imagen.This code writes a prompt to the console asking the user to enter an image URL. Después, llama a otro método, MakeAnalysisRequest, para procesar la imagen en esa ubicación.Then it calls another method, MakeAnalysisRequest, to process the image at that location.

        static void Main(string[] args)
        {

            // Get the path and filename to process from the user.
            Console.WriteLine("Detect faces:");
            Console.Write(
                "Enter the path to an image with faces that you wish to analyze: ");
            string imageFilePath = Console.ReadLine();

            if (File.Exists(imageFilePath))
            {
                try
                {
                    MakeAnalysisRequest(imageFilePath);
                    Console.WriteLine("\nWait a moment for the results to appear.\n");
                }
                catch (Exception e)
                {
                    Console.WriteLine("\n" + e.Message + "\nPress Enter to exit...\n");
                }
            }
            else
            {
                Console.WriteLine("\nInvalid file path.\nPress Enter to exit...\n");
            }
            Console.ReadLine();
        }

Llamada a la API REST de detección de carasCall the face detection REST API

Agregue el método siguiente a la clase Program.Add the following method to the Program class. Construye una llamada REST a Face API para detectar información de caras en la imagen remota (la cadena requestParameters especifica qué atributos de cara recuperar).It constructs a REST call to the Face API to detect face information in the remote image (the requestParameters string specifies which face attributes to retrieve). A continuación, escribe los datos de salida en una cadena JSON.Then it writes the output data to a JSON string.

Los métodos auxiliares se definirán en los pasos siguientes.You will define the helper methods in the following steps.

        // Gets the analysis of the specified image by using the Face REST API.
        static async void MakeAnalysisRequest(string imageFilePath)
        {
            HttpClient client = new HttpClient();

            // Request headers.
            client.DefaultRequestHeaders.Add(
                "Ocp-Apim-Subscription-Key", subscriptionKey);

            // Request parameters. A third optional parameter is "details".
            string requestParameters = "returnFaceId=true&returnFaceLandmarks=false" +
                "&returnFaceAttributes=age,gender,headPose,smile,facialHair,glasses," +
                "emotion,hair,makeup,occlusion,accessories,blur,exposure,noise";

            // Assemble the URI for the REST API Call.
            string uri = uriBase + "?" + requestParameters;

            HttpResponseMessage response;

            // Request body. Posts a locally stored JPEG image.
            byte[] byteData = GetImageAsByteArray(imageFilePath);

            using (ByteArrayContent content = new ByteArrayContent(byteData))
            {
                // This example uses content type "application/octet-stream".
                // The other content types you can use are "application/json"
                // and "multipart/form-data".
                content.Headers.ContentType =
                    new MediaTypeHeaderValue("application/octet-stream");

                // Execute the REST API call.
                response = await client.PostAsync(uri, content);

                // Get the JSON response.
                string contentString = await response.Content.ReadAsStringAsync();

                // Display the JSON response.
                Console.WriteLine("\nResponse:\n");
                Console.WriteLine(JsonPrettyPrint(contentString));
                Console.WriteLine("\nPress Enter to exit...");
            }
        }

Procesamiento de los datos de la imagen de entradaProcess the input image data

Agregue el método siguiente a la clase Program.Add the following method to the Program class. Este método convierte la imagen de la dirección URL especificada en una matriz de bytes.This method converts the image at the specified URL into a byte array.

        // Returns the contents of the specified file as a byte array.
        static byte[] GetImageAsByteArray(string imageFilePath)
        {
            using (FileStream fileStream =
                new FileStream(imageFilePath, FileMode.Open, FileAccess.Read))
            {
                BinaryReader binaryReader = new BinaryReader(fileStream);
                return binaryReader.ReadBytes((int)fileStream.Length);
            }
        }

Procese la respuesta JSON.Parse the JSON response

Agregue el método siguiente a la clase Program.Add the following method to the Program class. Este método da formato a la entrada JSON para que sea más fácil de leer.This method formats the JSON input to be more easily readable. La aplicación escribirá estos datos de cadena en la consola.Your app will write this string data to the console. A continuación, puede cerrar la clase y el espacio de nombres.You can then close the class and namespace.

        // Formats the given JSON string by adding line breaks and indents.
        static string JsonPrettyPrint(string json)
        {
            if (string.IsNullOrEmpty(json))
                return string.Empty;

            json = json.Replace(Environment.NewLine, "").Replace("\t", "");

            StringBuilder sb = new StringBuilder();
            bool quote = false;
            bool ignore = false;
            int offset = 0;
            int indentLength = 3;

            foreach (char ch in json)
            {
                switch (ch)
                {
                    case '"':
                        if (!ignore) quote = !quote;
                        break;
                    case '\'':
                        if (quote) ignore = !ignore;
                        break;
                }

                if (quote)
                    sb.Append(ch);
                else
                {
                    switch (ch)
                    {
                        case '{':
                        case '[':
                            sb.Append(ch);
                            sb.Append(Environment.NewLine);
                            sb.Append(new string(' ', ++offset * indentLength));
                            break;
                        case '}':
                        case ']':
                            sb.Append(Environment.NewLine);
                            sb.Append(new string(' ', --offset * indentLength));
                            sb.Append(ch);
                            break;
                        case ',':
                            sb.Append(ch);
                            sb.Append(Environment.NewLine);
                            sb.Append(new string(' ', offset * indentLength));
                            break;
                        case ':':
                            sb.Append(ch);
                            sb.Append(' ');
                            break;
                        default:
                            if (ch != ' ') sb.Append(ch);
                            break;
                    }
                }
            }

            return sb.ToString().Trim();
        }
    }
}

Ejecución de la aplicaciónRun the app

Una respuesta correcta mostrará datos de las caras en formato JSON fácilmente legible.A successful response will display Face data in easily readable JSON format. Por ejemplo:For example:

[
   {
      "faceId": "f7eda569-4603-44b4-8add-cd73c6dec644",
      "faceRectangle": {
         "top": 131,
         "left": 177,
         "width": 162,
         "height": 162
      },
      "faceAttributes": {
         "smile": 0.0,
         "headPose": {
            "pitch": 0.0,
            "roll": 0.1,
            "yaw": -32.9
         },
         "gender": "female",
         "age": 22.9,
         "facialHair": {
            "moustache": 0.0,
            "beard": 0.0,
            "sideburns": 0.0
         },
         "glasses": "NoGlasses",
         "emotion": {
            "anger": 0.0,
            "contempt": 0.0,
            "disgust": 0.0,
            "fear": 0.0,
            "happiness": 0.0,
            "neutral": 0.986,
            "sadness": 0.009,
            "surprise": 0.005
         },
         "blur": {
            "blurLevel": "low",
            "value": 0.06
         },
         "exposure": {
            "exposureLevel": "goodExposure",
            "value": 0.67
         },
         "noise": {
            "noiseLevel": "low",
            "value": 0.0
         },
         "makeup": {
            "eyeMakeup": true,
            "lipMakeup": true
         },
         "accessories": [

         ],
         "occlusion": {
            "foreheadOccluded": false,
            "eyeOccluded": false,
            "mouthOccluded": false
         },
         "hair": {
            "bald": 0.0,
            "invisible": false,
            "hairColor": [
               {
                  "color": "brown",
                  "confidence": 1.0
               },
               {
                  "color": "black",
                  "confidence": 0.87
               },
               {
                  "color": "other",
                  "confidence": 0.51
               },
               {
                  "color": "blond",
                  "confidence": 0.08
               },
               {
                  "color": "red",
                  "confidence": 0.08
               },
               {
                  "color": "gray",
                  "confidence": 0.02
               }
            ]
         }
      }
   }
]

Pasos siguientesNext steps

En esta guía de inicio rápido, ha creado una sencilla aplicación de consola de .NET que usa llamadas REST a Azure Face API para detectar caras en una imagen y devolver sus atributos.In this quickstart, you created a simple .NET console application that uses REST calls with the Azure Face API to detect faces in an image and return their attributes. A continuación, explore la documentación de referencia de Face API para más información sobre los escenarios admitidos.Next, explore the Face API reference documentation to learn more about the supported scenarios.