Szybki start: wykrywanie twarzy na obrazie przy użyciu interfejsu API REST i języka JavaQuickstart: Detect faces in an image using the REST API and Java

W tym przewodniku Szybki start użyjesz interfejsu API REST rozpoznawania twarzy platformy Azure i języka Java do wykrywania ludzkich twarzy na obrazie.In this quickstart, you will use the Azure Face REST API with Java to detect human faces in an image.

Jeśli nie masz subskrypcji platformy Azure, przed rozpoczęciem utwórz bezpłatne konto.If you don't have an Azure subscription, create a free account before you begin.

Wymagania wstępnePrerequisites

  • Klucz subskrypcji interfejsu API rozpoznawania twarzy.A Face API subscription key. Klucz subskrypcji bezpłatnej wersji próbnej możesz uzyskać na stronie Wypróbuj usługi Cognitive Services.You can get a free trial subscription key from Try Cognitive Services. Możesz też wykonać instrukcje z tematu Create a Cognitive Services account (Tworzenie konta usług Cognitive Services), aby subskrybować usługę interfejsu API rozpoznawania twarzy i uzyskać klucz.Or, follow the instructions in Create a Cognitive Services account to subscribe to the Face API service and get your key.
  • Wybrane środowisko IDE Java.Any Java IDE of your choice.

Tworzenie projektu języka JavaCreate the Java project

  1. Utwórz nową aplikację wiersza polecenia języka Java w środowisku IDE i dodaj klasę Main z metodą main.Create a new command line Java app in your IDE and add a Main class with a main method.
  2. Zaimportuj poniższe biblioteki do projektu języka Java.Import the following libraries into your Java project. Jeśli używasz programu Maven, współrzędne programu Maven są udostępniane w każdej bibliotece.If you're using Maven, the Maven coordinates are provided for each library.

Dodawanie kodu służącego do wykrywania twarzyAdd face detection code

Otwórz główną klasę projektu.Open the main class of your project. W tym pliku dodasz kod wymagany do ładowania obrazów i wykrywania twarzy.Here, you will add the code needed to load images and detect faces.

Importowanie pakietówImport packages

Dodaj poniższe instrukcje import na początku pliku.Add the following import statements to the top of the file.

// This sample uses Apache HttpComponents:
// http://hc.apache.org/httpcomponents-core-ga/httpcore/apidocs/
// https://hc.apache.org/httpcomponents-client-ga/httpclient/apidocs/

import java.net.URI;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.util.EntityUtils;
import org.json.JSONArray;
import org.json.JSONObject;

Dodawanie podstawowych pólAdd essential fields

Zastąp Main klasy z następującym kodem.Replace the Main class with the following code. Te dane służą do określania sposobu nawiązywania połączenia z usługą rozpoznawania twarzy i lokalizacji, z której można pobrać dane wejściowe.This data specifies how to connect to the Face service and where to get the input data. Należy zaktualizować pole subscriptionKey wartością klucza subskrypcji. Konieczna może być również zmiana ciągu uriBase w taki sposób, aby zawierał on poprawny identyfikator regionu (zobacz dokumentację interfejsu API rozpoznawania twarzy, aby zapoznać się z listą wszystkich punktów końcowych regionów).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). Możesz również ustawić wartość imageWithFaces na ścieżkę, która wskazuje na inny plik obrazu.You may also wish to set the imageWithFaces value to a path that points to a different image file.

Pole faceAttributes to po prostu lista atrybutów określonych typów.The faceAttributes field is simply a list of certain types of attributes. Będzie ono określać informacje dotyczące wykrytych twarzy, które mają zostać pobrane.It will specify which information to retrieve about the detected faces.

public class Main {
    // Replace <Subscription Key> with your valid subscription key.
    private static final 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.
    private static final String uriBase =
        "https://westcentralus.api.cognitive.microsoft.com/face/v1.0/detect";

    private static final String imageWithFaces =
        "{\"url\":\"https://upload.wikimedia.org/wikipedia/commons/c/c3/RH_Louise_Lillian_Gish.jpg\"}";

    private static final String faceAttributes =
        "age,gender,headPose,smile,facialHair,glasses,emotion,hair,makeup,occlusion,accessories,blur,exposure,noise";

Wywoływanie interfejsu API REST wykrywania twarzyCall the face detection REST API

Dodaj głównego metoda następującym kodem.Add the main method with the following code. Tworzy on wywołanie REST do interfejsu API rozpoznawania twarzy w celu wykrycia informacji o twarzy na obrazie zdalnym (ciąg faceAttributes określa, które atrybuty dotyczące twarzy mają zostać pobrane).It constructs a REST call to the Face API to detect face information in the remote image (the faceAttributes string specifies which face attributes to retrieve). Następnie zapisuje dane wyjściowe do ciągu JSON.Then it writes the output data to a JSON string.

    public static void main(String[] args) {
        HttpClient httpclient = HttpClientBuilder.create().build();

        try
        {
            URIBuilder builder = new URIBuilder(uriBase);

            // Request parameters. All of them are optional.
            builder.setParameter("returnFaceId", "true");
            builder.setParameter("returnFaceLandmarks", "false");
            builder.setParameter("returnFaceAttributes", faceAttributes);

            // Prepare the URI for the REST API call.
            URI uri = builder.build();
            HttpPost request = new HttpPost(uri);

            // Request headers.
            request.setHeader("Content-Type", "application/json");
            request.setHeader("Ocp-Apim-Subscription-Key", subscriptionKey);

            // Request body.
            StringEntity reqEntity = new StringEntity(imageWithFaces);
            request.setEntity(reqEntity);

            // Execute the REST API call and get the response entity.
            HttpResponse response = httpclient.execute(request);
            HttpEntity entity = response.getEntity();

Analizowanie odpowiedzi w formacie JSONParse the JSON response

Bezpośrednio poniżej powyższego kodu dodaj następujący blok, który służy do konwertowania zwróconych danych JSON do bardziej czytelnego formatu przed wyświetleniem ich w konsoli.Directly below the previous code, add the following block, which converts the returned JSON data into a more easily readable format before printing it to the console. Na koniec zamknąć bloku try / catch głównego metody i Main klasy.Finally, close out the try-catch block, the main method, and the Main class.

            if (entity != null)
            {
                // Format and display the JSON response.
                System.out.println("REST Response:\n");

                String jsonString = EntityUtils.toString(entity).trim();
                if (jsonString.charAt(0) == '[') {
                    JSONArray jsonArray = new JSONArray(jsonString);
                    System.out.println(jsonArray.toString(2));
                }
                else if (jsonString.charAt(0) == '{') {
                    JSONObject jsonObject = new JSONObject(jsonString);
                    System.out.println(jsonObject.toString(2));
                } else {
                    System.out.println(jsonString);
                }
            }
        }
        catch (Exception e)
        {
            // Display error message.
            System.out.println(e.getMessage());
        }
    }
}

Uruchamianie aplikacjiRun the app

Skompiluj kod i uruchom go.Compile the code and run it. Odpowiedź oznaczająca powodzenie będzie zawierać dane dotyczące rozpoznawania twarzy w czytelnym formacie JSON w oknie konsoli.A successful response will display Face data in easily readable JSON format in the console window. Na przykład:For example:

[{
  "faceRectangle": {
    "top": 131,
    "left": 177,
    "width": 162,
    "height": 162
  },
  "faceAttributes": {
    "makeup": {
      "eyeMakeup": true,
      "lipMakeup": true
    },
    "facialHair": {
      "sideburns": 0,
      "beard": 0,
      "moustache": 0
    },
    "gender": "female",
    "accessories": [],
    "blur": {
      "blurLevel": "low",
      "value": 0.06
    },
    "headPose": {
      "roll": 0.1,
      "pitch": 0,
      "yaw": -32.9
    },
    "smile": 0,
    "glasses": "NoGlasses",
    "hair": {
      "bald": 0,
      "invisible": false,
      "hairColor": [
        {
          "color": "brown",
          "confidence": 1
        },
        {
          "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
        }
      ]
    },
    "emotion": {
      "contempt": 0,
      "surprise": 0.005,
      "happiness": 0,
      "neutral": 0.986,
      "sadness": 0.009,
      "disgust": 0,
      "anger": 0,
      "fear": 0
    },
    "exposure": {
      "value": 0.67,
      "exposureLevel": "goodExposure"
    },
    "occlusion": {
      "eyeOccluded": false,
      "mouthOccluded": false,
      "foreheadOccluded": false
    },
    "noise": {
      "noiseLevel": "low",
      "value": 0
    },
    "age": 22.9
  },
  "faceId": "49d55c17-e018-4a42-ba7b-8cbbdfae7c6f"
}]

Kolejne krokiNext steps

W tym przewodniku Szybki start utworzono prostą aplikację konsolową Java, która korzysta z wywołań REST wraz z interfejsem API rozpoznawania twarzy platformy Azure do wykrywania twarzy na obrazie i zwrócenia ich atrybutów.In this quickstart, you created a simple Java console application that uses REST calls with the Azure Face API to detect faces in an image and return their attributes. Następnie dowiesz się, jak wykonać inne operacje za pomocą tych funkcji w aplikacji systemu Android.Next, learn how to do more with this functionality in an Android application.