Detecta rostros

La detección de rostro detecta varios rostros en una imagen junto con los atributos faciales clave asociados, como el estado emocional o wearing headwear. No se admite el reconocimiento facial individual específico.

Imagen en la que se ven 2 rostros con y sin anotaciones
Crédito de la imagen: Himanshu Singh Gurjar en Unsplash (anotaciones agregadas).

Solicitudes de detección de rostro

Configura el proyecto de GCP y la autenticación

quickstart,gcloud_init vision.googleapis.com Cloud Vision API SERVICE_ACCOUNT True env_var

Detecta rostros en una imagen local

La API de Vision puede realizar una detección de características en un archivo de imagen local si envía los contenidos del archivo de imagen como una string codificada en base64 en el cuerpo de la solicitud.

LÍNEA DE CMD Y REST

Antes de usar cualquiera de los datos de solicitud que se muestran a continuación, realiza los siguientes reemplazos:

  • base64-encoded-image: es la representación en base64 (string ASCII) de los datos binarios de la imagen. Esta string debería ser similar a la siguiente:
    • /9j/4QAYRXhpZgAA...9tAVx/zDQDlGxn//2Q==
    Visita el tema Codificación en base64 para obtener más información.

Método HTTP y URL:

POST https://vision.googleapis.com/v1/images:annotate

Cuerpo JSON de la solicitud:

    {
      "requests": [
        {
          "image": {
            "content": "base64-encoded-image"
          },
          "features": [
            {
              "maxResults": 10,
              "type": "FACE_DETECTION"
            }
          ]
        }
      ]
    }
    

Para enviar tu solicitud, elige una de estas opciones:

curl

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

curl -X POST \
-H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
-H "Content-Type: application/json; charset=utf-8" \
-d @request.json \
https://vision.googleapis.com/v1/images:annotate

PowerShell

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

$cred = gcloud auth application-default print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
-Method POST `
-Headers $headers `
-ContentType: "application/json; charset=utf-8" `
-InFile request.json `
-Uri "https://vision.googleapis.com/v1/images:annotate" | Select-Object -Expand Content

Si la solicitud se realiza de forma correcta, el servidor muestra un código de estado HTTP 200 OK y la respuesta en formato JSON.

Una respuesta de FACE_DETECTION incluye cuadros de límites para todos los rostros detectados y puntos de referencia detectados en los rostros (ojos, nariz, boca, etc.), y calificaciones de confianza para las propiedades faciales y de imagen (alegría, tristeza, enojo, sorpresa, etcétera).

C#

Antes de probar esta muestra, sigue las instrucciones de configuración de C# que se encuentran en la Guía de inicio rápido de la API de Vision sobre cómo usar bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Vision para C#.

// Load an image from a local file.
    var image = Image.FromFile(filePath);
    var client = ImageAnnotatorClient.Create();
    var response = client.DetectFaces(image);
    int count = 1;
    foreach (var faceAnnotation in response)
    {
        Console.WriteLine("Face {0}:", count++);
        Console.WriteLine("  Joy: {0}", faceAnnotation.JoyLikelihood);
        Console.WriteLine("  Anger: {0}", faceAnnotation.AngerLikelihood);
        Console.WriteLine("  Sorrow: {0}", faceAnnotation.SorrowLikelihood);
        Console.WriteLine("  Surprise: {0}", faceAnnotation.SurpriseLikelihood);
    }

Go

Antes de probar esta muestra, sigue las instrucciones de configuración de Go que se encuentran en la Guía de inicio rápido de la API de Vision sobre cómo usar bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Vision para Go.


    // detectFaces gets faces from the Vision API for an image at the given file path.
    func detectFaces(w io.Writer, file string) error {
    	ctx := context.Background()

    	client, err := vision.NewImageAnnotatorClient(ctx)
    	if err != nil {
    		return err
    	}
    	defer client.Close()

    	f, err := os.Open(file)
    	if err != nil {
    		return err
    	}
    	defer f.Close()

    	image, err := vision.NewImageFromReader(f)
    	if err != nil {
    		return err
    	}
    	annotations, err := client.DetectFaces(ctx, image, nil, 10)
    	if err != nil {
    		return err
    	}
    	if len(annotations) == 0 {
    		fmt.Fprintln(w, "No faces found.")
    	} else {
    		fmt.Fprintln(w, "Faces:")
    		for i, annotation := range annotations {
    			fmt.Fprintln(w, "  Face", i)
    			fmt.Fprintln(w, "    Anger:", annotation.AngerLikelihood)
    			fmt.Fprintln(w, "    Joy:", annotation.JoyLikelihood)
    			fmt.Fprintln(w, "    Surprise:", annotation.SurpriseLikelihood)
    		}
    	}
    	return nil
    }
    

Java

Antes de probar esta muestra, sigue las instrucciones de configuración de Java que se encuentran en la Guía de inicio rápido de la API de Vision sobre cómo usar bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Vision para Java.

public static void detectFaces(String filePath, PrintStream out) throws Exception, IOException {
      List<AnnotateImageRequest> requests = new ArrayList<>();

      ByteString imgBytes = ByteString.readFrom(new FileInputStream(filePath));

      Image img = Image.newBuilder().setContent(imgBytes).build();
      Feature feat = Feature.newBuilder().setType(Type.FACE_DETECTION).build();
      AnnotateImageRequest request =
          AnnotateImageRequest.newBuilder().addFeatures(feat).setImage(img).build();
      requests.add(request);

      try (ImageAnnotatorClient client = ImageAnnotatorClient.create()) {
        BatchAnnotateImagesResponse response = client.batchAnnotateImages(requests);
        List<AnnotateImageResponse> responses = response.getResponsesList();

        for (AnnotateImageResponse res : responses) {
          if (res.hasError()) {
            out.printf("Error: %s\n", res.getError().getMessage());
            return;
          }

          // For full list of available annotations, see http://g.co/cloud/vision/docs
          for (FaceAnnotation annotation : res.getFaceAnnotationsList()) {
            out.printf(
                "anger: %s\njoy: %s\nsurprise: %s\nposition: %s",
                annotation.getAngerLikelihood(),
                annotation.getJoyLikelihood(),
                annotation.getSurpriseLikelihood(),
                annotation.getBoundingPoly());
          }
        }
      }
    }

Node.js

Antes de probar esta muestra, sigue las instrucciones de configuración de Node.js que se encuentran en la Guía de inicio rápido de la API de Vision sobre cómo usar bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Vision para Node.js.

// Imports the Google Cloud client library
    const vision = require('@google-cloud/vision');

    // Creates a client
    const client = new vision.ImageAnnotatorClient();

    /**
     * TODO(developer): Uncomment the following line before running the sample.
     */
    // const fileName = 'Local image file, e.g. /path/to/image.png';

    const [result] = await client.faceDetection(fileName);
    const faces = result.faceAnnotations;
    console.log('Faces:');
    faces.forEach((face, i) => {
      console.log(`  Face #${i + 1}:`);
      console.log(`    Joy: ${face.joyLikelihood}`);
      console.log(`    Anger: ${face.angerLikelihood}`);
      console.log(`    Sorrow: ${face.sorrowLikelihood}`);
      console.log(`    Surprise: ${face.surpriseLikelihood}`);
    });

PHP

Antes de probar esta muestra, sigue las instrucciones de configuración de PHP que se encuentran en la Guía de inicio rápido de la API de Vision sobre cómo usar bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Vision para PHP.

namespace Google\Cloud\Samples\Vision;

    use Google\Cloud\Vision\V1\ImageAnnotatorClient;

    function detect_face($path, $outFile = null)
    {
        $imageAnnotator = new ImageAnnotatorClient();

        # annotate the image
        // $path = 'path/to/your/image.jpg'
        $image = file_get_contents($path);
        $response = $imageAnnotator->faceDetection($image);
        $faces = $response->getFaceAnnotations();

        # names of likelihood from google.cloud.vision.enums
        $likelihoodName = ['UNKNOWN', 'VERY_UNLIKELY', 'UNLIKELY',
        'POSSIBLE', 'LIKELY', 'VERY_LIKELY'];

        printf("%d faces found:" . PHP_EOL, count($faces));
        foreach ($faces as $face) {
            $anger = $face->getAngerLikelihood();
            printf("Anger: %s" . PHP_EOL, $likelihoodName[$anger]);

            $joy = $face->getJoyLikelihood();
            printf("Joy: %s" . PHP_EOL, $likelihoodName[$joy]);

            $surprise = $face->getSurpriseLikelihood();
            printf("Surprise: %s" . PHP_EOL, $likelihoodName[$surprise]);

            # get bounds
            $vertices = $face->getBoundingPoly()->getVertices();
            $bounds = [];
            foreach ($vertices as $vertex) {
                $bounds[] = sprintf('(%d,%d)', $vertex->getX(), $vertex->getY());
            }
            print('Bounds: ' . join(', ', $bounds) . PHP_EOL);
            print(PHP_EOL);
        }
    }

Python

Antes de probar esta muestra, sigue las instrucciones de configuración de Python que se encuentran en la Guía de inicio rápido de la API de Vision sobre cómo usar bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Vision para Python.

def detect_faces(path):
        """Detects faces in an image."""
        from google.cloud import vision
        import io
        client = vision.ImageAnnotatorClient()

        with io.open(path, 'rb') as image_file:
            content = image_file.read()

        image = vision.types.Image(content=content)

        response = client.face_detection(image=image)
        faces = response.face_annotations

        # Names of likelihood from google.cloud.vision.enums
        likelihood_name = ('UNKNOWN', 'VERY_UNLIKELY', 'UNLIKELY', 'POSSIBLE',
                           'LIKELY', 'VERY_LIKELY')
        print('Faces:')

        for face in faces:
            print('anger: {}'.format(likelihood_name[face.anger_likelihood]))
            print('joy: {}'.format(likelihood_name[face.joy_likelihood]))
            print('surprise: {}'.format(likelihood_name[face.surprise_likelihood]))

            vertices = (['({},{})'.format(vertex.x, vertex.y)
                        for vertex in face.bounding_poly.vertices])

            print('face bounds: {}'.format(','.join(vertices)))

        if response.error.message:
            raise Exception(
                '{}\nFor more info on error messages, check: '
                'https://cloud.google.com/apis/design/errors'.format(
                    response.error.message))

Ruby

Antes de probar esta muestra, sigue las instrucciones de configuración de Ruby que se encuentran en la Guía de inicio rápido de la API de Vision sobre cómo usar bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Vision para Ruby.

# image_path = "Path to local image file, eg. './image.png'"

    require "google/cloud/vision"

    image_annotator = Google::Cloud::Vision::ImageAnnotator.new

    response = image_annotator.face_detection image: image_path

    response.responses.each do |res|
      res.face_annotations.each do |face|
        puts "Joy:      #{face.joy_likelihood}"
        puts "Anger:    #{face.anger_likelihood}"
        puts "Sorrow:   #{face.sorrow_likelihood}"
        puts "Surprise: #{face.surprise_likelihood}"
      end
    end

Detecta rostros en una imagen remota

Para tu comodidad, la API de Vision puede realizar una detección de características directamente en un archivo de imagen ubicado en Google Cloud Storage o en la Web, sin necesidad de enviar el contenido del archivo de imagen en el cuerpo de tu solicitud.

LÍNEA DE CMD Y REST

Antes de usar cualquiera de los datos de solicitud que se muestran a continuación, realiza los siguientes reemplazos:

  • cloud-storage-image-uri: es la ruta de acceso a un archivo de imagen válido en un depósito de Cloud Storage. Como mínimo, debes tener privilegios de lectura en el archivo. Ejemplo:
    • gs://cloud-samples-data/vision/face/faces.jpeg

Método HTTP y URL:

POST https://vision.googleapis.com/v1/images:annotate

Cuerpo JSON de la solicitud:

    {
      "requests": [
        {
          "image": {
            "source": {
              "imageUri": "cloud-storage-image-uri"
            }
           },
           "features": [
             {
               "maxResults": 10,
               "type": "FACE_DETECTION"
             }
           ]
        }
      ]
    }
    

Para enviar tu solicitud, elige una de estas opciones:

curl

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

curl -X POST \
-H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
-H "Content-Type: application/json; charset=utf-8" \
-d @request.json \
https://vision.googleapis.com/v1/images:annotate

PowerShell

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

$cred = gcloud auth application-default print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
-Method POST `
-Headers $headers `
-ContentType: "application/json; charset=utf-8" `
-InFile request.json `
-Uri "https://vision.googleapis.com/v1/images:annotate" | Select-Object -Expand Content

Si la solicitud se realiza de forma correcta, el servidor muestra un código de estado HTTP 200 OK y la respuesta en formato JSON.

Una respuesta de FACE_DETECTION incluye cuadros de límites para todos los rostros detectados y puntos de referencia detectados en los rostros (ojos, nariz, boca, etc.), y calificaciones de confianza para las propiedades faciales y de imagen (alegría, tristeza, enojo, sorpresa, etcétera).

C#

Antes de probar esta muestra, sigue las instrucciones de configuración de C# que se encuentran en la Guía de inicio rápido de la API de Vision sobre cómo usar bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Vision para C#.

// Specify a Google Cloud Storage uri for the image
    // or a publicly accessible HTTP or HTTPS uri.
    var image = Image.FromUri(uri);
    var client = ImageAnnotatorClient.Create();
    var response = client.DetectFaces(image);
    int count = 1;
    foreach (var faceAnnotation in response)
    {
        Console.WriteLine("Face {0}:", count++);
        Console.WriteLine("  Joy: {0}", faceAnnotation.JoyLikelihood);
        Console.WriteLine("  Anger: {0}", faceAnnotation.AngerLikelihood);
        Console.WriteLine("  Sorrow: {0}", faceAnnotation.SorrowLikelihood);
        Console.WriteLine("  Surprise: {0}", faceAnnotation.SurpriseLikelihood);
    }

Go

Antes de probar esta muestra, sigue las instrucciones de configuración de Go que se encuentran en la Guía de inicio rápido de la API de Vision sobre cómo usar bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Vision para Go.


    // detectFaces gets faces from the Vision API for an image at the given file path.
    func detectFacesURI(w io.Writer, file string) error {
    	ctx := context.Background()

    	client, err := vision.NewImageAnnotatorClient(ctx)
    	if err != nil {
    		return err
    	}

    	image := vision.NewImageFromURI(file)
    	annotations, err := client.DetectFaces(ctx, image, nil, 10)
    	if err != nil {
    		return err
    	}
    	if len(annotations) == 0 {
    		fmt.Fprintln(w, "No faces found.")
    	} else {
    		fmt.Fprintln(w, "Faces:")
    		for i, annotation := range annotations {
    			fmt.Fprintln(w, "  Face", i)
    			fmt.Fprintln(w, "    Anger:", annotation.AngerLikelihood)
    			fmt.Fprintln(w, "    Joy:", annotation.JoyLikelihood)
    			fmt.Fprintln(w, "    Surprise:", annotation.SurpriseLikelihood)
    		}
    	}
    	return nil
    }
    

Java

Antes de probar esta muestra, sigue las instrucciones de configuración de Java que se encuentran en la Guía de inicio rápido de la API de Vision sobre cómo usar bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Vision para Java.

public static void detectFacesGcs(String gcsPath, PrintStream out) throws Exception,
        IOException {
      List<AnnotateImageRequest> requests = new ArrayList<>();

      ImageSource imgSource = ImageSource.newBuilder().setGcsImageUri(gcsPath).build();
      Image img = Image.newBuilder().setSource(imgSource).build();
      Feature feat = Feature.newBuilder().setType(Type.FACE_DETECTION).build();

      AnnotateImageRequest request =
          AnnotateImageRequest.newBuilder().addFeatures(feat).setImage(img).build();
      requests.add(request);

      try (ImageAnnotatorClient client = ImageAnnotatorClient.create()) {
        BatchAnnotateImagesResponse response = client.batchAnnotateImages(requests);
        List<AnnotateImageResponse> responses = response.getResponsesList();

        for (AnnotateImageResponse res : responses) {
          if (res.hasError()) {
            out.printf("Error: %s\n", res.getError().getMessage());
            return;
          }

          // For full list of available annotations, see http://g.co/cloud/vision/docs
          for (FaceAnnotation annotation : res.getFaceAnnotationsList()) {
            out.printf(
                "anger: %s\njoy: %s\nsurprise: %s\nposition: %s",
                annotation.getAngerLikelihood(),
                annotation.getJoyLikelihood(),
                annotation.getSurpriseLikelihood(),
                annotation.getBoundingPoly());
          }
        }
      }
    }

Node.js

Antes de probar esta muestra, sigue las instrucciones de configuración de Node.js que se encuentran en la Guía de inicio rápido de la API de Vision sobre cómo usar bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Vision para Node.js.

// Imports the Google Cloud client libraries
    const vision = require('@google-cloud/vision');

    // Creates a client
    const client = new vision.ImageAnnotatorClient();

    /**
     * TODO(developer): Uncomment the following lines before running the sample.
     */
    // const bucketName = 'Bucket where the file resides, e.g. my-bucket';
    // const fileName = 'Path to file within bucket, e.g. path/to/image.png';

    // Performs face detection on the gcs file
    const [result] = await client.faceDetection(`gs://${bucketName}/${fileName}`);
    const faces = result.faceAnnotations;
    console.log('Faces:');
    faces.forEach((face, i) => {
      console.log(`  Face #${i + 1}:`);
      console.log(`    Joy: ${face.joyLikelihood}`);
      console.log(`    Anger: ${face.angerLikelihood}`);
      console.log(`    Sorrow: ${face.sorrowLikelihood}`);
      console.log(`    Surprise: ${face.surpriseLikelihood}`);
    });

PHP

Antes de probar esta muestra, sigue las instrucciones de configuración de PHP que se encuentran en la Guía de inicio rápido de la API de Vision sobre cómo usar bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Vision para PHP.

namespace Google\Cloud\Samples\Vision;

    use Google\Cloud\Vision\V1\ImageAnnotatorClient;

    // $path = 'gs://path/to/your/image.jpg'

    function detect_face_gcs($path)
    {
        $imageAnnotator = new ImageAnnotatorClient();

        # annotate the image
        $response = $imageAnnotator->faceDetection($path);
        $faces = $response->getFaceAnnotations();

        # names of likelihood from google.cloud.vision.enums
        $likelihoodName = ['UNKNOWN', 'VERY_UNLIKELY', 'UNLIKELY',
        'POSSIBLE', 'LIKELY', 'VERY_LIKELY'];

        printf("%d faces found:" . PHP_EOL, count($faces));
        foreach ($faces as $face) {
            $anger = $face->getAngerLikelihood();
            printf("Anger: %s" . PHP_EOL, $likelihoodName[$anger]);

            $joy = $face->getJoyLikelihood();
            printf("Joy: %s" . PHP_EOL, $likelihoodName[$joy]);

            $surprise = $face->getSurpriseLikelihood();
            printf("Surprise: %s" . PHP_EOL, $likelihoodName[$surprise]);

            # get bounds
            $vertices = $face->getBoundingPoly()->getVertices();
            $bounds = [];
            foreach ($vertices as $vertex) {
                $bounds[] = sprintf('(%d,%d)', $vertex->getX(), $vertex->getY());
            }
            print('Bounds: ' . join(', ', $bounds) . PHP_EOL);
            print(PHP_EOL);
        }

        $imageAnnotator->close();
    }

Python

Antes de probar esta muestra, sigue las instrucciones de configuración de Python que se encuentran en la Guía de inicio rápido de la API de Vision sobre cómo usar bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Vision para Python.

def detect_faces_uri(uri):
        """Detects faces in the file located in Google Cloud Storage or the web."""
        from google.cloud import vision
        client = vision.ImageAnnotatorClient()
        image = vision.types.Image()
        image.source.image_uri = uri

        response = client.face_detection(image=image)
        faces = response.face_annotations

        # Names of likelihood from google.cloud.vision.enums
        likelihood_name = ('UNKNOWN', 'VERY_UNLIKELY', 'UNLIKELY', 'POSSIBLE',
                           'LIKELY', 'VERY_LIKELY')
        print('Faces:')

        for face in faces:
            print('anger: {}'.format(likelihood_name[face.anger_likelihood]))
            print('joy: {}'.format(likelihood_name[face.joy_likelihood]))
            print('surprise: {}'.format(likelihood_name[face.surprise_likelihood]))

            vertices = (['({},{})'.format(vertex.x, vertex.y)
                        for vertex in face.bounding_poly.vertices])

            print('face bounds: {}'.format(','.join(vertices)))

        if response.error.message:
            raise Exception(
                '{}\nFor more info on error messages, check: '
                'https://cloud.google.com/apis/design/errors'.format(
                    response.error.message))

Ruby

Antes de probar esta muestra, sigue las instrucciones de configuración de Ruby que se encuentran en la Guía de inicio rápido de la API de Vision sobre cómo usar bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Vision para Ruby.

# image_path = "Google Cloud Storage URI, eg. 'gs://my-bucket/image.png'"

    require "google/cloud/vision"

    image_annotator = Google::Cloud::Vision::ImageAnnotator.new

    response = image_annotator.face_detection image: image_path

    response.responses.each do |res|
      res.face_annotations.each do |face|
        puts "Joy:      #{face.joy_likelihood}"
        puts "Anger:    #{face.anger_likelihood}"
        puts "Sorrow:   #{face.sorrow_likelihood}"
        puts "Surprise: #{face.surprise_likelihood}"
      end
    end

Comando de gcloud

Para realizar una detección de rostro, usa el comando gcloud ml vision detect-faces como se muestra en el siguiente ejemplo:

    gcloud ml vision detect-faces gs://cloud-samples-data/vision/face/faces.jpeg
    

Pruébala

Prueba la detección de rostro que se muestra a continuación. Puedes usar la imagen ya especificada (gs://cloud-samples-data/vision/face/faces.jpeg) o especificar tu propia imagen en su lugar. Si deseas enviar la solicitud, selecciona Ejecutar (Execute).

Imagen en la que se ven 2 rostros con y sin anotaciones
Crédito de la imagen: Himanshu Singh Gurjar en Unsplash (anotaciones agregadas).