Quickstart: Gezichten in een afbeelding detecteren met de Face REST API en C#Quickstart: Detect faces in an image using the Face REST API and C#

In deze snelstart gebruikt u de Azure Face REST API met C# om menselijke gezichten in een afbeelding te detecteren.In this quickstart, you will use the Azure Face REST API with C# to detect human faces in an image.

Als u nog geen abonnement op Azure hebt, maak dan een gratis account aan voordat u begint.If you don't have an Azure subscription, create a free account before you begin.

VereistenPrerequisites

Het Visual Studio-project makenCreate the Visual Studio project

  1. Maak in Visual Studio een nieuw Console-app (.NET Framework)-project en noem het FaceDetection.In Visual Studio, create a new Console app (.NET Framework) project and name it FaceDetection.
  2. Als uw oplossing nog meer projecten bevat, selecteert u deze als het enkele opstartproject.If there are other projects in your solution, select this one as the single startup project.

Gezichtsdetectiecode toevoegenAdd face detection code

Open het bestand Program.cs van het nieuwe project.Open the new project's Program.cs file. Hier voegt u de code toe voor het laden van afbeeldingen en detecteren van gezichten.Here, you will add the code needed to load images and detect faces.

Naamruimten opnemenInclude namespaces

Voeg aan het begin van het bestand Program.cs de volgende using-instructies toe.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;

Essentiƫle velden toevoegenAdd essential fields

Voeg de programma klasse die de volgende velden bevat.Add the Program class containing the following fields. Met deze gegevens wordt aangegeven hoe de Face-service moet worden verbonden en waar de invoergegevens kunnen worden opgehaald.This data specifies how to connect to the Face service and where to get the input data. U moet het veld subscriptionKey bijwerken met de waarde van de abonnementssleutel en mogelijk moet u de tekenreeks uriBase wijzigen, zodat deze de juiste regio-id bevat (zie de Face API-documentatie voor een lijst met alle regio-eindpunten).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";

Invoer van de afbeelding ontvangenReceive image input

Voeg de volgende code toe aan de methode Main in de klasse Program.Add the following code to the Main method of the Program class. Hiermee wordt een prompt naar de console geschreven waarin de gebruiker wordt gevraagd een afbeeldings-URL in te voeren.This writes a prompt to the console asking the user to enter an image URL. Vervolgens wordt een andere methode, MakeAnalysisRequest, aangeroepen om de afbeelding op die locatie te verwerken.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();
        }

De REST API voor de gezichtsdetectie aanroepenCall the face detection REST API

Voeg de volgende methode toe aan de klasse Program.Add the following method to the Program class. Hiermee wordt een REST-aanroep naar de Face-API gemaakt om informatie over het gezicht te detecteren in de externe afbeelding (de tekenreeks requestParameters geeft aan welke gezichtskenmerken moeten worden opgehaald).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). Vervolgens worden de uitvoergegevens naar een JSON-tekenreeks geschreven.Then it writes the output data to a JSON string.

In de volgende stappen definieert u de hulpmethoden.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...");
            }
        }

De invoergegevens van de afbeelding verwerkenProcess the input image data

Voeg de volgende methode toe aan de klasse Program.Add the following method to the Program class. Hiermee wordt de afbeelding op de opgegeven URL geconverteerd naar een bytematrix.This 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);
            }
        }

Het JSON-antwoord parserenParse the JSON response

Voeg de volgende methode toe aan de klasse Program.Add the following method to the Program class. Hiermee wordt de JSON-invoer gemakkelijker leesbaar gemaakt.This formats the JSON input to be more easily readable. Met uw app worden deze tekenreeksgegevens naar de console geschreven.Your app will write this string data to the console. Vervolgens kunt u sluiten de klasse en de naamruimte.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();
        }
    }
}

De app uitvoerenRun the app

Bij een geslaagd antwoord worden de Face-gegevens weergegeven in een makkelijk leesbare JSON-indeling.A successful response will display Face data in easily readable JSON format. Bijvoorbeeld: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
               }
            ]
         }
      }
   }
]

Volgende stappenNext steps

In deze snelstart hebt u een eenvoudige .NET-consoletoepassing gemaakt die gebruikmaakt van REST-aanroepen met de Azure Face-API voor het detecteren van gezichten in een afbeelding en het retourneren van de kenmerken.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. Lees het naslagmateriaal bij de Face-API voor meer informatie over de ondersteunde scenario's.Next, explore the Face API reference documentation to learn more about the supported scenarios.