Snabbstart: Identifiera ansikten i en bild med ansikts-REST API och C#Quickstart: Detect faces in an image using the Face REST API and C#

I den här snabbstarten ska du använda Azure ansikts-REST API med C# för att identifiera mänskliga ansikten i en bild.In this quickstart, you will use the Azure Face REST API with C# to detect human faces in an image.

Om du inte har en Azure-prenumeration kan du skapa ett kostnadsfritt konto innan du börjar.If you don't have an Azure subscription, create a free account before you begin.

Nödvändiga komponenterPrerequisites

Skapa Visual Studio-projektetCreate the Visual Studio project

  1. Skapa ett nytt projekt för Konsolprogram (.NET Framework) i Visual Studio och ge det namnet FaceDetection.In Visual Studio, create a new Console app (.NET Framework) project and name it FaceDetection.
  2. Om det finns andra projekt i din lösning väljer du den här kopian som det enda startprojektet.If there are other projects in your solution, select this one as the single startup project.

Lägga till kod för ansiktsigenkänningAdd face detection code

Öppna det nya projektets Program.cs-fil.Open the new project's Program.cs file. Här lägger du till den kod som behövs för att läsa in bilder och identifiera ansikten.Here, you will add the code needed to load images and detect faces.

Inkludera namnområdenInclude namespaces

Lägg till följande using-instruktioner överst i Program.cs-filen.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;

Lägga till grundläggande fältAdd essential fields

Lägg till den programmet klass som innehåller följande fält.Add the Program class containing the following fields. Dessa data anger hur du ansluter till ansiktsigenkänningstjänsten och var du hämtar indata.This data specifies how to connect to the Face service and where to get the input data. Du måste uppdatera fältet subscriptionKey med värdet för din prenumerationsnyckel, och du kan behöva ändra strängen uriBase så att den innehåller rätt regionsidentifierare (en lista över alla regionsslutpunkter finns i dokument om Ansikts-API).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";

Ta emot indataReceive image input

Lägg till följande kod i metoden Main i klassen Program.Add the following code to the Main method of the Program class. Det här skriver en fråga till konsolen som ber användaren att ange en bild-URL.This writes a prompt to the console asking the user to enter an image URL. Sedan anropas en annan metod, MakeAnalysisRequest, för att bearbeta bilden på den platsen.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();
        }

Anropa REST API för ansiktsigenkänningCall the face detection REST API

Lägg till följande metod i klassen Program.Add the following method to the Program class. Den skapar ett REST-anrop till Ansikts-API för att identifiera ansiktsinformation i fjärrbilden (requestParameters-strängen anger vilka ansiktsattribut som ska hämtas).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). Sedan skriver den utdata till en JSON-sträng.Then it writes the output data to a JSON string.

Du definierar hjälpmetoden i följande steg.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...");
            }
        }

Bearbeta inmatade bilddataProcess the input image data

Lägg till följande metod i klassen Program.Add the following method to the Program class. Det här konverterar bilden på den angivna URL:en till en bytematris.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);
            }
        }

Tolka JSON-svaretParse the JSON response

Lägg till följande metod i klassen Program.Add the following method to the Program class. Det här formaterar JSON-indata så att de blir mer lättlästa.This formats the JSON input to be more easily readable. Appen skriver dessa strängdata till konsolen.Your app will write this string data to the console. Därefter kan du stänga den klass och namnområde.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();
        }
    }
}

Kör appenRun the app

Ett lyckat svar visar ansiktsinformation i lättläst JSON-format.A successful response will display Face data in easily readable JSON format. Exempel: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
               }
            ]
         }
      }
   }
]

Nästa stegNext steps

I den här snabbstarten har du skapat ett enkelt .NET-konsolprogram som använder REST-anrop med Ansikts-API i Azure för att identifiera ansikten i en bild och returnera deras attribut.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. Utforska sedan referensdokumentationen för Ansikts-API för att lära dig mer om de scenarier som stöds.Next, explore the Face API reference documentation to learn more about the supported scenarios.