Schnellstart: Erkennen von Gesichtern in einem Bild mit der Gesichtserkennungs-REST-API und C#Quickstart: Detect faces in an image using the Face REST API and C#

In dieser Schnellstartanleitung verwenden Sie die Azure-Gesichtserkennungs-REST-API mit C#, um menschliche Gesichter in einem Bild zu erkennen.In this quickstart, you will use the Azure Face REST API with C# to detect human faces in an image.

Wenn Sie kein Azure-Abonnement besitzen, können Sie ein kostenloses Konto erstellen, bevor Sie beginnen.If you don't have an Azure subscription, create a free account before you begin.

VoraussetzungenPrerequisites

Erstellen des Visual Studio-ProjektsCreate the Visual Studio project

  1. Erstellen Sie in Visual Studio ein neues Projekt vom Typ Konsolen-App (.NET Framework) , und nennen Sie es FaceDetection.In Visual Studio, create a new Console app (.NET Framework) project and name it FaceDetection.
  2. Sollte Ihre Projektmappe noch andere Projekte enthalten, wählen Sie dieses Projekt als das alleinige Startprojekt aus.If there are other projects in your solution, select this one as the single startup project.

Hinzufügen von Code für die GesichtserkennungAdd face detection code

Öffnen Sie die Datei Program.cs des neuen Projekts.Open the new project's Program.cs file. Hier fügen Sie den Code hinzu, der zum Laden von Bildern und Erkennen von Gesichtern erforderlich ist.Here, you will add the code needed to load images and detect faces.

Einschließen von NamespacesInclude namespaces

Fügen Sie am Anfang der Datei Program.cs die folgenden using-Anweisungen hinzu: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;

Hinzufügen wichtiger FelderAdd essential fields

Fügen Sie die Program-Klasse mit den folgenden Felder hinzu.Add the Program class containing the following fields. Mit diesen Daten wird angegeben, wie eine Verbindung mit dem Gesichtserkennungsdienst hergestellt wird und wo die Eingabedaten abgerufen werden.This data specifies how to connect to the Face service and where to get the input data. Sie müssen das Feld subscriptionKey mit dem Wert Ihres Abonnementschlüssels aktualisieren. Unter Umständen müssen Sie die Zeichenfolge uriBase ändern, sodass sie die Zeichenfolge des Ressourcenendpunkts enthält.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.

Hinweis

Neue Ressourcen, die nach dem 1. Juli 2019 erstellt wurden, verwenden benutzerdefinierte Unterdomänennamen.New resources created after July 1, 2019, will use custom subdomain names. Weitere Informationen und eine vollständige Liste mit regionalen Endpunkten finden Sie unter Benutzerdefinierte Unterdomänennamen für Cognitive Services.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";

Empfangen der BildeingabeReceive image input

Fügen Sie der Main-Methode der Program-Klasse den folgenden Code hinzu.Add the following code to the Main method of the Program class. Durch diesen Code wird der Benutzer über die Konsole aufgefordert, eine Bild-URL einzugeben.This code writes a prompt to the console asking the user to enter an image URL. Anschließend wird eine weitere Methode (MakeAnalysisRequest) aufgerufen, um das Bild an diesem Speicherort zu verarbeiten.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();
        }

Aufrufen der Gesichtserkennungs-REST-APICall the face detection REST API

Fügen Sie der Program-Klasse die folgende Methode hinzu.Add the following method to the Program class. Diese Methode erstellt einen REST-Aufruf der Gesichtserkennungs-API, um Gesichtsinformationen im Remotebild zu erkennen. (Die Zeichenfolge requestParameters gibt an, welche Gesichtsattribute abgerufen werden sollen.)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). Anschließend werden die Ausgabedaten in eine JSON-Zeichenfolge geschrieben.Then it writes the output data to a JSON string.

Sie definieren die Hilfsmethoden in den folgenden Schritten.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...");
            }
        }

Verarbeiten der EingabebilddatenProcess the input image data

Fügen Sie der Program-Klasse die folgende Methode hinzu.Add the following method to the Program class. Durch diese Methode wird das Bild unter der angegebenen URL in ein Bytearray konvertiert.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);
            }
        }

Analysieren der JSON-AntwortParse the JSON response

Fügen Sie der Program-Klasse die folgende Methode hinzu.Add the following method to the Program class. Durch diese Methode wird die JSON-Antwort formatiert, damit sie besser lesbar ist.This method formats the JSON input to be more easily readable. Ihre App schreibt diese Zeichenfolgendaten in die Konsole.Your app will write this string data to the console. Anschließend können Sie die Klasse und den Namespace schließen.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();
        }
    }
}

Ausführen der AppRun the app

Eine erfolgreiche Antwort zeigt Gesichtserkennungsdaten in leicht lesbarem JSON-Format an.A successful response will display Face data in easily readable JSON format. Beispiel: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ächste SchritteNext steps

In dieser Schnellstartanleitung haben Sie eine einfache .NET-Konsolenanwendung erstellt, die REST-Aufrufe mit der Azure-Gesichtserkennungs-API verwendet, um Gesichter in einem Bild zu erkennen und ihre Attribute zurückzugeben.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. Sehen Sie sich als Nächstes die Referenzdokumentation zur Gesichtserkennungs-API an, um mehr über die unterstützten Szenarien zu erfahren.Next, explore the Face API reference documentation to learn more about the supported scenarios.