Inicio rápido: Detección de caras en una imagen mediante la API REST y JavaQuickstart: Detect faces in an image using the REST API and Java

En este tutorial, usará la API REST de Azure Face con Java para detectar caras humanas en una imagen.In this quickstart, you will use the Azure Face REST API with Java to detect human faces in an image.

Si no tiene una suscripción a Azure, cree una cuenta gratuita antes de empezar.If you don't have an Azure subscription, create a free account before you begin.

Requisitos previosPrerequisites

Creación del proyecto de JavaCreate the Java project

  1. Cree una nueva aplicación de Java de la línea de comandos en el IDE y agregue una clase Main con un método main.Create a new command-line Java app in your IDE and add a Main class with a main method.
  2. Importe las bibliotecas siguientes en el proyecto de Java.Import the following libraries into your Java project. Si usa Maven, se proporcionan las coordenadas de Maven para cada biblioteca.If you're using Maven, the Maven coordinates are provided for each library.

Adición del código de detección de carasAdd face detection code

Abra la clase main del proyecto.Open the main class of your project. Aquí, agregará el código necesario para cargar imágenes y detectar caras.Here, you will add the code needed to load images and detect faces.

Importación de paquetesImport packages

Agregue las siguientes instrucciones import en la parte superior del archivo.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;

Adición de los campos esencialesAdd essential fields

Reemplace la clase Main por el código siguiente.Replace the Main class with the following code. Estos datos especifican cómo conectarse al servicio Face y dónde obtener los datos de entrada.This data specifies how to connect to the Face service and where to get the input data. Deberá actualizar el campo subscriptionKey con el valor de la clave de suscripción y es posible que deba cambiar la cadena uriBase para que contenga el identificador de la región correcta (consulte la documentación de Face API para obtener una lista de los puntos de conexión de todas las regiones).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). También es posible que desee establecer el valor de imageWithFaces en una ruta de acceso que apunte a un archivo de imagen diferente.You may also wish to set the imageWithFaces value to a path that points to a different image file.

El campo faceAttributes es simplemente una lista de determinados tipos de atributos.The faceAttributes field is simply a list of certain types of attributes. Especificará qué información recuperar sobre las caras detectadas.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";

Llamada a la API REST de detección de carasCall the face detection REST API

Agregue el método main con el código siguiente.Add the main method with the following code. Construye una llamada REST a Face API para detectar información de caras en la imagen remota (la cadena faceAttributes especifica qué atributos de cara recuperar).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). A continuación, escribe los datos de salida en una cadena 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();

Procese la respuesta JSON.Parse the JSON response

Agregue el siguiente bloque directamente debajo del código anterior, que convierte los datos JSON devueltos en un formato más fácil de leer antes de imprimirlo en la consola.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. Por último, cierre el bloque try-catch, el método main y la clase Main.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());
        }
    }
}

Ejecución de la aplicaciónRun the app

Compile el código y ejecútelo.Compile the code and run it. Una respuesta correcta mostrará datos de las caras en formato JSON fácilmente legible en la ventana de consola.A successful response will display Face data in easily readable JSON format in the console window. Por ejemplo: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"
}]

Pasos siguientesNext steps

En esta guía de inicio rápido, ha creado una sencilla aplicación de consola de Java que usa llamadas REST a Azure Face API para detectar caras en una imagen y devolver sus atributos.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. A continuación, obtenga información sobre cómo hacer más cosas con esta funcionalidad en una aplicación Android.Next, learn how to do more with this functionality in an Android application.