Início rápido: Detectar faces em uma imagem usando a API REST de face eC#Quickstart: Detect faces in an image using the Face REST API and C#

Neste guia de início rápido, você usará a API REST do C# Azure face para detectar faces humanas em uma imagem.In this quickstart, you will use the Azure Face REST API with C# to detect human faces in an image.

Se não tiver uma subscrição do Azure, crie uma conta gratuita antes de começar.If you don't have an Azure subscription, create a free account before you begin.

Pré-requisitosPrerequisites

Criar o projeto do Visual StudioCreate the Visual Studio project

  1. No Visual Studio, crie um novo projeto de aplicativo de console (.NET Framework) e nomeie-o FaceDetection.In Visual Studio, create a new Console app (.NET Framework) project and name it FaceDetection.
  2. Se houver outros projetos na sua solução, selecione esta como o único projeto de arranque.If there are other projects in your solution, select this one as the single startup project.

Adicionar código de detecção facialAdd face detection code

Abra o arquivo Program.cs do novo projeto.Open the new project's Program.cs file. Aqui, você adicionará o código necessário para carregar imagens e detectar rostos.Here, you will add the code needed to load images and detect faces.

Incluir espaços de nomesInclude namespaces

Adicione as declarações using seguintes à parte superior do ficheiro 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;

Adicionar campos essenciaisAdd essential fields

Adicione a classe programa que contém os campos a seguir.Add the Program class containing the following fields. Esses dados especificam como se conectar ao serviço de face e onde obter os dados de entrada.This data specifies how to connect to the Face service and where to get the input data. Você precisará atualizar o subscriptionKey campo com o valor de sua chave de assinatura e talvez precise alterar a uriBase cadeia de caracteres para que ela contenha a cadeia de caracteres do ponto de extremidade do recurso.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 your resource endpoint string.

Nota

Novos recursos criados após 1º de julho de 2019 usarão nomes de subdomínio personalizados.New resources created after July 1, 2019, will use custom subdomain names. Para obter mais informações e uma lista completa de pontos de extremidade regionais, consulte nomes de subdomínio personalizados para serviços cognitivas.For more information and a complete list of regional endpoints, see Custom subdomain names for Cognitive Services.

namespace DetectFace
{
    class Program
    {

        // Replace <Subscription Key> with your valid subscription key.
        const string subscriptionKey = "<Subscription Key>";
        
        // replace <myresourcename> with the string found in your endpoint URL
        const string uriBase =
            "https://<myresourcename>.cognitive.microsoft.com/face/v1.0/detect";

Entrada de imagem de recebimentoReceive image input

Adicione o código a seguir ao método Main da classe Program .Add the following code to the Main method of the Program class. Esse código grava um prompt no console solicitando que o usuário insira uma URL de imagem.This code writes a prompt to the console asking the user to enter an image URL. Em seguida, ele chama outro método, MakeAnalysisRequest, para processar a imagem nesse local.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();
        }

Chamar a API REST de detecção facialCall the face detection REST API

Adicione o seguinte método à classe Programa.Add the following method to the Program class. Ele constrói uma chamada REST para o API de detecção facial para detectar informações de face na imagem remota (a cadeia requestParameters de caracteres especifica quais atributos de face 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). Em seguida, ele grava os dados de saída em uma cadeia de caracteres JSON.Then it writes the output data to a JSON string.

Você definirá os métodos auxiliares nas etapas a seguir.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...");
            }
        }

Processar os dados da imagem de entradaProcess the input image data

Adicione o seguinte método à classe Programa.Add the following method to the Program class. Esse método converte a imagem na URL especificada em uma 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);
            }
        }

Analisar a resposta JSONParse the JSON response

Adicione o seguinte método à classe Programa.Add the following method to the Program class. Esse método formata a entrada JSON para ser legível com mais facilidade.This method formats the JSON input to be more easily readable. Seu aplicativo gravará esses dados de cadeia de caracteres no console.Your app will write this string data to the console. Em seguida, você pode fechar a classe e o namespace.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();
        }
    }
}

Executar a aplicaçãoRun the app

Uma resposta bem-sucedida exibirá dados de face em formato JSON facilmente legível.A successful response will display Face data in easily readable JSON format. Por exemplo: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
               }
            ]
         }
      }
   }
]

Passos SeguintesNext steps

Neste guia de início rápido, você criou um aplicativo de console .NET simples que usa chamadas REST com o API de Detecção Facial do Azure para detectar rostos em uma imagem e retornar seus 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. Em seguida, explore a documentação de referência do API de Detecção Facial para saber mais sobre os cenários com suporte.Next, explore the Face API reference documentation to learn more about the supported scenarios.