Ir a la consola

Detecta rostros con el Kit de AA en Android

Puedes usar el Kit de AA para detectar rostros en imágenes y videos, mediante un modelo en el dispositivo o uno en la nube. Consulta la descripción general para obtener más información sobre los beneficios de cada enfoque.

Antes de comenzar

  1. Configura un proyecto de Firebase:
    1. Crea un proyecto en Firebase console si no lo hiciste antes. Si ya tienes un proyecto de Google asociado con tu app para dispositivos móviles, haz clic en Importar proyecto de Google. De lo contrario, haz clic en Agregar proyecto.
    2. Haz clic en Agrega Firebase a tu app para Android y sigue los pasos de la configuración. Si estás importando un proyecto de Google existente, es posible que esto suceda de forma automática y solo tengas que descargar el archivo de configuración.
    3. Ingresa el nombre del paquete de la app cuando se te solicite. Es importante que ingreses el nombre del paquete que usa tu app. Esto solo se puede configurar cuando agregas una app a tu proyecto de Firebase.
    4. Para finalizar el proceso, descargarás un archivo google-services.json. Puedes volver a descargar el archivo de configuración en cualquier momento.
    5. Si aún no lo haces, copia esto en la carpeta del módulo de tu proyecto, que generalmente es app/.
  2. Extrae el SDK, que recibiste de tu contacto de EAP:
    unzip -d $SDK_DIR 3p_sdk.m2repo.zip
    
  3. Agrega el directorio en el que extrajiste el SDK y el complemento de Servicios de Google al archivo build.gradle del nivel de tu proyecto:
    buildscript {
      // ...
      dependencies {
          // ...
          classpath 'com.google.gms:google-services:3.2.0' // google-services plugin
      }
    }
    
    allprojects {
      repositories {
        // Add this
        maven {
          url "$SDK_DIR"
        }
        // This should already be here
        jcenter()
    
        ...
      }
    }
    
  4. Luego, incluye la dependencia para el Kit de AA y agrega la línea apply plugin al archivo build.gradle del nivel de tu app:

    dependencies {
      // ...
      compile 'com.google.firebase:firebase-core:12.8.0-SNAPSHOT'
      compile 'com.google.firebase:firebase-ml-vision:12.8.0-SNAPSHOT'
    }
    
    // ADD THIS AT THE BOTTOM OF THE FILE
    apply plugin: 'com.google.gms.google-services'
    

Ahora estás listo para detectar rostros mediante un modelo en el dispositivo o un modelo basado en la nube.

Detección de rostros en el dispositivo

Configura el detector de rostros

Antes de aplicar la detección de rostros a una imagen, si deseas modificar la configuración predeterminada del detector de rostros, especifica la configuración con un objeto FirebaseVisionFaceDetectorOptions. Puedes cambiar las siguientes opciones de configuración:

Configuración
Modo de detección FAST_MODE (predeterminado) | ACCURATE_MODE

Prefiere la velocidad o la precisión en la detección de rostros.

Detectar puntos de referencia NO_LANDMARKS (predeterminado) | ALL_LANDMARKS

Indica si se debe intentar identificar "puntos de referencia" faciales: ojos, orejas, nariz, mejillas, boca.

Clasificar rostros NO_CLASSIFICATIONS (predeterminado) | ALL_CLASSIFICATIONS

Indica si se deben clasificar los rostros en categorías como "sonriente" y "ojos abiertos".

Tamaño mínimo del rostro float (predeterminado: 0.1f)

El tamaño mínimo, en relación con la imagen, de los rostros que se detectarán.

Habilitar el seguimiento de rostros false (predeterminado) | true

Indica si se deben asignar ID a los rostros, que se pueden usar para seguir los rostros entre imágenes.

Por ejemplo, para cambiar todos los elementos de la configuración predeterminada, compila un objeto FirebaseVisionFaceDetectorOptions como el siguiente:

FirebaseVisionFaceDetectorOptions options =
    new FirebaseVisionFaceDetectorOptions.Builder()
        .setModeType(FirebaseVisionFaceDetectorOptions.ACCURATE_MODE)
        .setLandmarkType(FirebaseVisionFaceDetectorOptions.ALL_LANDMARKS)
        .setClassificationType(FirebaseVisionFaceDetectorOptions.ALL_CLASSIFICATIONS)
        .setMinFaceSize(0.2f)
        .setTrackingEnabled(true)
        .build();

Ejecuta el detector de rostros

Para reconocer rostros en una imagen, pasa la imagen como un objeto ByteBuffer al método FirebaseVisionFaceDetector de detectInBuffer o como un objeto android.graphics.Bitmap al método detectInImage.

  1. Obtén una instancia de FirebaseVisionFaceDetector:

    FirebaseVisionFaceDetector detector = FirebaseVision.getInstance()
        .getVisionFaceDetector(options);
    
  2. Crea un objeto FirebaseVisionImageMetadata que contenga los metadatos de la imagen.

    Si pasas la imagen como un ByteBuffer, debes especificar su altura, ancho, formato de codificación del color y orientación:

    FirebaseVisionImageMetadata metadata = new FirebaseVisionImageMetadata.Builder()
        .setWidth(1280)
        .setHeight(720)
        .setFormat(FirebaseVisionImageMetadata.IMAGE_FORMAT_NV21)
        .setRotation(FirebaseVisionImageMetadata.ROTATION_0)
        .build();
    

    Si pasas la imagen como un Bitmap, solo debes especificar su orientación:

    FirebaseVisionImageMetadata metadata = new FirebaseVisionImageMetadata.Builder()
        .setRotation(FirebaseVisionImageMetadata.ROTATION_0)
        .build();
    
  3. Por último, pasa la imagen al método detectInBuffer o detectInImage:

    Task<SparseArray<FirebaseVisionFace>> result =
        detector.detectInImage(image, metadata)  // or detectInBuffer(buffer, metadata)
        .addOnSuccessListener(
            this,
            new OnSuccessListener<SparseArray<FirebaseVisionFace>>() {
              @Override
              public void onSuccess(SparseArray<FirebaseVisionFace> faces) {
                // Task completed successfully
                // ...
              }
            })
        .addOnFailureListener(
            this,
            new OnFailureListener() {
              @Override
              public void onFailure(@NonNull Exception e) {
                // Task failed with an exception
                // ...
              }
            });
    

Obtén información sobre los rostros detectados

Si la operación de reconocimiento de rostros se ejecuta correctamente, se pasará un arreglo de objetos FirebaseVisionFace al agente de escucha que detecta el resultado correcto. Cada objeto FirebaseVisionFace representa un rostro que se detectó en la imagen. Para cada rostro, puedes obtener las coordenadas de sus límites en la imagen de entrada, junto con cualquier otra información que encuentre el detector de rostros según la configuración que le asignaste. Por ejemplo:

for(int i = 0; i < faces.size(); i++) {
  FirebaseVisionFace face = faces.valueAt(i);

  Rect bounds = face.getBoundingBox();
  if (face.hasHeadEulerAngleY()) {
    float rotY = face.getHeadEulerAngleY();  // Head is rotated to the right rotY degrees
  }
  if (face.hasHeadEulerAngleZ()) {
    float rotZ = face.getHeadEulerAngleZ();  // Head is rotated upward rotZ degrees
  }

  // If landmark detection was enabled (mouth, ears, eyes, cheeks, and
  // nose available):
  if (face.hasLeftEarPosition()) {
    PointF leftEarPos = face.getLeftEarPosition();
  }
  if (face.hasNoseBasePosition()) {
    PointF nosePos = face.getNoseBasePosition();
  }

  // If classification was enabled:
  if (face.hasSmilingProbability()) {
    float smileProb = face.getSmilingProbability();
  }
  if (face.hasRightEyeOpenProbability()) {
    float rightEyeOpenProb = face.getRightEyeOpenProbability();
  }

  // If face tracking was enabled:
  if (face.hasTrackingId()) {
    int id = face.getTrackingId();
  }
}

Detección de rostros en la nube

Configura el detector de rostros

Según la configuración predeterminada, el detector de Cloud usa la versión STABLE del modelo y muestra hasta 10 resultados. Si deseas modificar esta configuración, especifícala con un objeto FirebaseVisionCloudDetectorOptions.

Por ejemplo, para cambiar ambos elementos de la configuración predeterminada, compila un objeto FirebaseVisionCloudDetectorOptions como el siguiente:

FirebaseVisionCloudDetectorOptions options =
    new FirebaseVisionCloudDetectorOptions.Builder()
        .setModelType(FirebaseVisionCloudDetectorOptions.LATEST_MODEL)
        .setMaxResults(15)
        .build();

Para usar la configuración predeterminada, puedes usar FirebaseVisionCloudDetectorOptions.DEFAULT en este paso.

Ejecuta el detector de rostros

Para reconocer logotipos en una imagen, pasa la imagen como un objeto ByteBuffer al método FirebaseVisionCloudFaceDetector de detectInBuffer o como un objeto android.graphics.Bitmap al método detectInImage.

  1. Obtén una instancia de FirebaseVisionCloudFaceDetector:

    FirebaseVisionCloudFaceDetector detector = FirebaseMachineLearning.getInstance()
        .getVisionFaceDetector(options);
    
  2. Crea un objeto FirebaseVisionImageMetadata que contenga los metadatos de la imagen.

    Si pasas la imagen como un ByteBuffer, debes especificar su altura, ancho, formato de codificación del color y orientación:

    FirebaseVisionImageMetadata metadata = new FirebaseVisionImageMetadata.Builder()
        .setWidth(1280)
        .setHeight(720)
        .setFormat(FirebaseVisionImageMetadata.IMAGE_FORMAT_NV21)
        .setRotation(FirebaseVisionImageMetadata.ROTATION_0)
        .build();
    

    Si pasas la imagen como un Bitmap, solo debes especificar su orientación:

    FirebaseVisionImageMetadata metadata = new FirebaseVisionImageMetadata.Builder()
        .setRotation(FirebaseVisionImageMetadata.ROTATION_0)
        .build();
    
  3. Por último, pasa la imagen al método detectInBuffer o detectInImage:

    Task<SparseArray<FirebaseVisionCloudFace>> result =
        detector.detectInImage(image, metadata)  // or detectInBuffer(buffer, metadata)
        .addOnSuccessListener(
            this,
            new OnSuccessListener<SparseArray<FirebaseVisionCloudFace>>() {
              @Override
              public void onSuccess(SparseArray<FirebaseVisionCloudFace> faces) {
                // Task completed successfully
                // ...
              }
            })
        .addOnFailureListener(
            this,
            new OnFailureListener() {
              @Override
              public void onFailure(@NonNull Exception e) {
                // Task failed with an exception
                // ...
              }
            });
    

Obtén información sobre los rostros detectados

Si la operación de reconocimiento de rostros se ejecuta correctamente, se pasará un arreglo de objetos FirebaseVisionCloudFace al agente de escucha que detecta el resultado correcto. Cada objeto FirebaseVisionCloudFace representa un rostro que se detectó en la imagen. Para cada rostro, puedes obtener las coordenadas de sus límites en la imagen de entrada, su rotación en relación con la cámara y la ubicación de los rasgos faciales detectados. Por ejemplo:

for(int i = 0; i < faces.size(); i++) {
  FirebaseVisionFace face = faces.valueAt(i);

  // Face position and rotation
  Rect bounds = face.getBoundingBox();
  float rotY = face.getHeadEulerAngleY();  // Head is rotated to the right rotY degrees
  float rotZ = face.getHeadEulerAngleZ();  // Head is rotated upward rotZ degrees

  // Facial features
  PointF leftEarPos = face.getLeftEarPosition();
  PointF nosePos = face.getNoseBasePosition();

  // Face classification
  float sorrowProb = face.getSorrowProbability();
  float rightEyeOpenProb = face.getRightEyeOpenProbability();
}