Rileva i volti con ML Kit su Android

Puoi utilizzare ML Kit per rilevare i volti nelle immagini e nei video.

Prima di iniziare

  1. Se non l'hai già fatto, aggiungi Firebase al tuo progetto Android.
  2. Aggiungi al modulo le dipendenze per le librerie Android di ML Kit file Gradle (a livello di app) (di solito app/build.gradle): 
    apply plugin: 'com.android.application'
apply plugin: 'com.google.gms.google-services'

dependencies {
  // ...

  implementation 'com.google.firebase:firebase-ml-vision:24.0.3'
  // If you want to detect face contours (landmark detection and classification
  // don't require this additional model):
  implementation 'com.google.firebase:firebase-ml-vision-face-model:20.0.1'
}
  3. Facoltativo ma consigliato: configura il download automatico dell'app il modello ML sul dispositivo dopo l'installazione dell'app dal Play Store.

    Per farlo, aggiungi la seguente dichiarazione alla sezione File AndroidManifest.xml:

    <application ...>
  ...
  <meta-data
      android:name="com.google.firebase.ml.vision.DEPENDENCIES"
      android:value="face" />
  <!-- To use multiple models: android:value="face,model2,model3" -->
</application>
     Se non abiliti il download del modello al momento dell'installazione, il modello verrà viene scaricato la prima volta che esegui il rilevatore. Le richieste che effettui prima il download completato non produrrà risultati.

Linee guida per l'immagine di input

Affinché ML Kit possa rilevare accuratamente i volti, le immagini di input devono contenere volti rappresentate da dati pixel sufficienti. In generale, ogni volto che vuoi da rilevare in un'immagine devono essere di almeno 100 x 100 pixel. Se vuoi rilevare i contorni delle facce, ML Kit richiede un input di risoluzione più alta: ogni faccia deve essere di almeno 200 x 200 pixel.

Se rilevi i volti in un'applicazione in tempo reale, potresti anche per considerare le dimensioni complessive delle immagini di input. Le immagini più piccole possono essere elaborate più velocemente, quindi per ridurre la latenza, acquisisci le immagini a risoluzioni inferiori (tenendo presente i requisiti di accuratezza sopra indicati) e assicurati che il volto del soggetto occupi la maggior parte dell'immagine. Vedi anche Suggerimenti per migliorare il rendimento in tempo reale.

Una scarsa messa a fuoco dell'immagine può influire negativamente sulla precisione. Se non ottieni risultati accettabili, prova a chiedere all'utente di recuperare l'immagine.

L'orientamento di un volto rispetto alla fotocamera può influire anche sul viso rileva le funzionalità di ML Kit. Consulta Rilevamento facciale Concetti.

1. Configurare il rilevatore di volti

Prima di applicare il rilevamento dei volti a un'immagine, se vuoi modificare una delle impostazioni predefinite del rilevatore di volti, specifica tali impostazioni con un FirebaseVisionFaceDetectorOptions. Puoi modificare le seguenti impostazioni:

Impostazioni
Modalità prestazioni FAST (valore predefinito) | ACCURATE

Prediligi la velocità o la precisione nel rilevamento dei volti.
Rilevamento dei punti di riferimento NO_LANDMARKS (valore predefinito) | ALL_LANDMARKS

Se tentare di identificare i "punti di riferimento" facciali: occhi, orecchie, naso guance, bocca e così via.
Rileva i livelli NO_CONTOURS (valore predefinito) | ALL_CONTOURS

Se rilevare i contorni dei tratti del viso. I contorni sono rilevato solo per il volto più in evidenza in un'immagine.
Classificare i volti NO_CLASSIFICATIONS (valore predefinito) | ALL_CLASSIFICATIONS

Se classificare o meno i volti in categorie come "sorriso", e "con gli occhi aperti".
Dimensioni minime del volto float (valore predefinito: 0.1f)

La dimensione minima dei volti da rilevare in relazione all'immagine.
Attiva rilevamento dei volti false (predefinito) | true

Indica se assegnare o meno ai volti un ID, che può essere utilizzato per il tracciamento volti attraverso le immagini.

Tieni presente che quando il rilevamento del contorno è attivo, viene selezionato un solo volto viene rilevato, quindi il rilevamento dei volti non produce risultati utili. Per questo motivo, e per migliorare la velocità di rilevamento, non attivare sia il rilevamento dei contorni sia il monitoraggio del volto.

Ad esempio:

Java 

// High-accuracy landmark detection and face classification
FirebaseVisionFaceDetectorOptions highAccuracyOpts =
        new FirebaseVisionFaceDetectorOptions.Builder()
                .setPerformanceMode(FirebaseVisionFaceDetectorOptions.ACCURATE)
                .setLandmarkMode(FirebaseVisionFaceDetectorOptions.ALL_LANDMARKS)
                .setClassificationMode(FirebaseVisionFaceDetectorOptions.ALL_CLASSIFICATIONS)
                .build();

// Real-time contour detection of multiple faces
FirebaseVisionFaceDetectorOptions realTimeOpts =
        new FirebaseVisionFaceDetectorOptions.Builder()
                .setContourMode(FirebaseVisionFaceDetectorOptions.ALL_CONTOURS)
                .build();

Kotlin+KTX 

// High-accuracy landmark detection and face classification
val highAccuracyOpts = FirebaseVisionFaceDetectorOptions.Builder()
        .setPerformanceMode(FirebaseVisionFaceDetectorOptions.ACCURATE)
        .setLandmarkMode(FirebaseVisionFaceDetectorOptions.ALL_LANDMARKS)
        .setClassificationMode(FirebaseVisionFaceDetectorOptions.ALL_CLASSIFICATIONS)
        .build()

// Real-time contour detection of multiple faces
val realTimeOpts = FirebaseVisionFaceDetectorOptions.Builder()
        .setContourMode(FirebaseVisionFaceDetectorOptions.ALL_CONTOURS)
        .build()

2. Usa il rilevatore di volti

Per rilevare i volti in un'immagine, crea un oggetto FirebaseVisionImage da un array di byte Bitmap, media.Image, ByteBuffer, o da un file del dispositivo. Quindi, passa l'oggetto FirebaseVisionImage Metodo detectInImage di FirebaseVisionFaceDetector.

Per il riconoscimento facciale, devi utilizzare un'immagine con dimensioni di almeno 480 x 360 pixel. Se riconosci i volti in tempo reale, acquisire fotogrammi con questa risoluzione minima può contribuire a ridurre la latenza.

  1. Crea un oggetto FirebaseVisionImage dal tuo dell'immagine.

    • Per creare un oggetto FirebaseVisionImage da un media.Image, ad esempio quando acquisisci un'immagine da un fotocamera del dispositivo, passa l'oggetto media.Image e l'oggetto rotazione in FirebaseVisionImage.fromMediaImage().

      Se utilizzi nella libreria di CameraX, OnImageCapturedListener e ImageAnalysis.Analyzer classi calcolano il valore di rotazione quindi devi solo convertire la rotazione in una Costanti ROTATION_ prima di chiamare FirebaseVisionImage.fromMediaImage():

      Java

      private class YourAnalyzer implements ImageAnalysis.Analyzer {

    private int degreesToFirebaseRotation(int degrees) {
        switch (degrees) {
            case 0:
                return FirebaseVisionImageMetadata.ROTATION_0;
            case 90:
                return FirebaseVisionImageMetadata.ROTATION_90;
            case 180:
                return FirebaseVisionImageMetadata.ROTATION_180;
            case 270:
                return FirebaseVisionImageMetadata.ROTATION_270;
            default:
                throw new IllegalArgumentException(
                        "Rotation must be 0, 90, 180, or 270.");
        }
    }

    @Override
    public void analyze(ImageProxy imageProxy, int degrees) {
        if (imageProxy == null || imageProxy.getImage() == null) {
            return;
        }
        Image mediaImage = imageProxy.getImage();
        int rotation = degreesToFirebaseRotation(degrees);
        FirebaseVisionImage image =
                FirebaseVisionImage.fromMediaImage(mediaImage, rotation);
        // Pass image to an ML Kit Vision API
        // ...
    }
}

      Kotlin+KTX

      private class YourImageAnalyzer : ImageAnalysis.Analyzer {
    private fun degreesToFirebaseRotation(degrees: Int): Int = when(degrees) {
        0 -> FirebaseVisionImageMetadata.ROTATION_0
        90 -> FirebaseVisionImageMetadata.ROTATION_90
        180 -> FirebaseVisionImageMetadata.ROTATION_180
        270 -> FirebaseVisionImageMetadata.ROTATION_270
        else -> throw Exception("Rotation must be 0, 90, 180, or 270.")
    }

    override fun analyze(imageProxy: ImageProxy?, degrees: Int) {
        val mediaImage = imageProxy?.image
        val imageRotation = degreesToFirebaseRotation(degrees)
        if (mediaImage != null) {
            val image = FirebaseVisionImage.fromMediaImage(mediaImage, imageRotation)
            // Pass image to an ML Kit Vision API
            // ...
        }
    }
}

      Se non utilizzi una raccolta di videocamere che ti fornisce la rotazione dell'immagine, può calcolarla in base alla rotazione del dispositivo e all'orientamento della fotocamera nel dispositivo:

      Java

      private static final SparseIntArray ORIENTATIONS = new SparseIntArray();
static {
    ORIENTATIONS.append(Surface.ROTATION_0, 90);
    ORIENTATIONS.append(Surface.ROTATION_90, 0);
    ORIENTATIONS.append(Surface.ROTATION_180, 270);
    ORIENTATIONS.append(Surface.ROTATION_270, 180);
}

/**
 * Get the angle by which an image must be rotated given the device's current
 * orientation.
 */
@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
private int getRotationCompensation(String cameraId, Activity activity, Context context)
        throws CameraAccessException {
    // Get the device's current rotation relative to its "native" orientation.
    // Then, from the ORIENTATIONS table, look up the angle the image must be
    // rotated to compensate for the device's rotation.
    int deviceRotation = activity.getWindowManager().getDefaultDisplay().getRotation();
    int rotationCompensation = ORIENTATIONS.get(deviceRotation);

    // On most devices, the sensor orientation is 90 degrees, but for some
    // devices it is 270 degrees. For devices with a sensor orientation of
    // 270, rotate the image an additional 180 ((270 + 270) % 360) degrees.
    CameraManager cameraManager = (CameraManager) context.getSystemService(CAMERA_SERVICE);
    int sensorOrientation = cameraManager
            .getCameraCharacteristics(cameraId)
            .get(CameraCharacteristics.SENSOR_ORIENTATION);
    rotationCompensation = (rotationCompensation + sensorOrientation + 270) % 360;

    // Return the corresponding FirebaseVisionImageMetadata rotation value.
    int result;
    switch (rotationCompensation) {
        case 0:
            result = FirebaseVisionImageMetadata.ROTATION_0;
            break;
        case 90:
            result = FirebaseVisionImageMetadata.ROTATION_90;
            break;
        case 180:
            result = FirebaseVisionImageMetadata.ROTATION_180;
            break;
        case 270:
            result = FirebaseVisionImageMetadata.ROTATION_270;
            break;
        default:
            result = FirebaseVisionImageMetadata.ROTATION_0;
            Log.e(TAG, "Bad rotation value: " + rotationCompensation);
    }
    return result;
}
      VisionImage.java

      Kotlin+KTX

      private val ORIENTATIONS = SparseIntArray()

init {
    ORIENTATIONS.append(Surface.ROTATION_0, 90)
    ORIENTATIONS.append(Surface.ROTATION_90, 0)
    ORIENTATIONS.append(Surface.ROTATION_180, 270)
    ORIENTATIONS.append(Surface.ROTATION_270, 180)
}
/**
 * Get the angle by which an image must be rotated given the device's current
 * orientation.
 */
@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
@Throws(CameraAccessException::class)
private fun getRotationCompensation(cameraId: String, activity: Activity, context: Context): Int {
    // Get the device's current rotation relative to its "native" orientation.
    // Then, from the ORIENTATIONS table, look up the angle the image must be
    // rotated to compensate for the device's rotation.
    val deviceRotation = activity.windowManager.defaultDisplay.rotation
    var rotationCompensation = ORIENTATIONS.get(deviceRotation)

    // On most devices, the sensor orientation is 90 degrees, but for some
    // devices it is 270 degrees. For devices with a sensor orientation of
    // 270, rotate the image an additional 180 ((270 + 270) % 360) degrees.
    val cameraManager = context.getSystemService(CAMERA_SERVICE) as CameraManager
    val sensorOrientation = cameraManager
            .getCameraCharacteristics(cameraId)
            .get(CameraCharacteristics.SENSOR_ORIENTATION)!!
    rotationCompensation = (rotationCompensation + sensorOrientation + 270) % 360

    // Return the corresponding FirebaseVisionImageMetadata rotation value.
    val result: Int
    when (rotationCompensation) {
        0 -> result = FirebaseVisionImageMetadata.ROTATION_0
        90 -> result = FirebaseVisionImageMetadata.ROTATION_90
        180 -> result = FirebaseVisionImageMetadata.ROTATION_180
        270 -> result = FirebaseVisionImageMetadata.ROTATION_270
        else -> {
            result = FirebaseVisionImageMetadata.ROTATION_0
            Log.e(TAG, "Bad rotation value: $rotationCompensation")
        }
    }
    return result
}
      VisionImage.kt

      Quindi, passa l'oggetto media.Image e valore di rotazione a FirebaseVisionImage.fromMediaImage():

      Java

      FirebaseVisionImage image = FirebaseVisionImage.fromMediaImage(mediaImage, rotation);
      VisionImage.java

      Kotlin+KTX

      val image = FirebaseVisionImage.fromMediaImage(mediaImage, rotation)
      VisionImage.kt
    • Per creare un oggetto FirebaseVisionImage da un URI del file, passa il contesto dell'app e l'URI del file FirebaseVisionImage.fromFilePath(). Questa opzione è utile quando utilizzi un'intenzione ACTION_GET_CONTENT per chiedere all'utente di selezionare un'immagine dalla sua app Galleria.

      Java

      FirebaseVisionImage image;
try {
    image = FirebaseVisionImage.fromFilePath(context, uri);
} catch (IOException e) {
    e.printStackTrace();
}
      VisionImage.java

      Kotlin+KTX

      val image: FirebaseVisionImage
try {
    image = FirebaseVisionImage.fromFilePath(context, uri)
} catch (e: IOException) {
    e.printStackTrace()
}
      VisionImage.kt
    • Per creare un oggetto FirebaseVisionImage da un ByteBuffer o da un array di byte, calcola prima la rotazione dell'immagine come descritto sopra per l'input media.Image.

      Quindi, crea un oggetto FirebaseVisionImageMetadata che contiene l'altezza, la larghezza, il formato di codifica del colore, e rotazione:

      Java

      FirebaseVisionImageMetadata metadata = new FirebaseVisionImageMetadata.Builder()
        .setWidth(480)   // 480x360 is typically sufficient for
        .setHeight(360)  // image recognition
        .setFormat(FirebaseVisionImageMetadata.IMAGE_FORMAT_NV21)
        .setRotation(rotation)
        .build();
      VisionImage.java

      Kotlin+KTX

      val metadata = FirebaseVisionImageMetadata.Builder()
        .setWidth(480) // 480x360 is typically sufficient for
        .setHeight(360) // image recognition
        .setFormat(FirebaseVisionImageMetadata.IMAGE_FORMAT_NV21)
        .setRotation(rotation)
        .build()
      VisionImage.kt

      Utilizza il buffer o l'array e l'oggetto metadati per creare un Oggetto FirebaseVisionImage:

      Java

      FirebaseVisionImage image = FirebaseVisionImage.fromByteBuffer(buffer, metadata);
// Or: FirebaseVisionImage image = FirebaseVisionImage.fromByteArray(byteArray, metadata);
      VisionImage.java

      Kotlin+KTX

      val image = FirebaseVisionImage.fromByteBuffer(buffer, metadata)
// Or: val image = FirebaseVisionImage.fromByteArray(byteArray, metadata)
      VisionImage.kt
    • Per creare un oggetto FirebaseVisionImage da un Oggetto Bitmap:

      Java

      FirebaseVisionImage image = FirebaseVisionImage.fromBitmap(bitmap);
      VisionImage.java

      Kotlin+KTX

      val image = FirebaseVisionImage.fromBitmap(bitmap)
      VisionImage.kt
      L'immagine rappresentata dall'oggetto Bitmap deve in posizione verticale, senza la necessità di ulteriori rotazioni.

  2. Recupera un'istanza di FirebaseVisionFaceDetector:

    Java 

    FirebaseVisionFaceDetector detector = FirebaseVision.getInstance()
        .getVisionFaceDetector(options);

    Kotlin+KTX 

    val detector = FirebaseVision.getInstance()
        .getVisionFaceDetector(options)

  3. Infine, passa l'immagine al metodo detectInImage:

    Java 

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

    Kotlin+KTX 

    val result = detector.detectInImage(image)
        .addOnSuccessListener { faces ->
            // Task completed successfully
            // ...
        }
        .addOnFailureListener { e ->
            // Task failed with an exception
            // ...
        }

3. Ricevere informazioni sui volti rilevati

Se il riconoscimento del volto ha esito positivo, viene visualizzato un elenco di FirebaseVisionFace oggetti verranno passati all'esito positivo e ascolto. Ogni oggetto FirebaseVisionFace rappresenta un volto rilevato come mostrato nell'immagine. Per ogni faccia, puoi visualizzare le coordinate di delimitazione nell'input immagine, nonché qualsiasi altra informazione configurata dal rilevatore di volti da trovare. Ad esempio:

Java 

for (FirebaseVisionFace face : faces) {
    Rect bounds = face.getBoundingBox();
    float rotY = face.getHeadEulerAngleY();  // Head is rotated to the right rotY degrees
    float rotZ = face.getHeadEulerAngleZ();  // Head is tilted sideways rotZ degrees

    // If landmark detection was enabled (mouth, ears, eyes, cheeks, and
    // nose available):
    FirebaseVisionFaceLandmark leftEar = face.getLandmark(FirebaseVisionFaceLandmark.LEFT_EAR);
    if (leftEar != null) {
        FirebaseVisionPoint leftEarPos = leftEar.getPosition();
    }

    // If contour detection was enabled:
    List<FirebaseVisionPoint> leftEyeContour =
            face.getContour(FirebaseVisionFaceContour.LEFT_EYE).getPoints();
    List<FirebaseVisionPoint> upperLipBottomContour =
            face.getContour(FirebaseVisionFaceContour.UPPER_LIP_BOTTOM).getPoints();

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

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

Kotlin+KTX 

for (face in faces) {
    val bounds = face.boundingBox
    val rotY = face.headEulerAngleY // Head is rotated to the right rotY degrees
    val rotZ = face.headEulerAngleZ // Head is tilted sideways rotZ degrees

    // If landmark detection was enabled (mouth, ears, eyes, cheeks, and
    // nose available):
    val leftEar = face.getLandmark(FirebaseVisionFaceLandmark.LEFT_EAR)
    leftEar?.let {
        val leftEarPos = leftEar.position
    }

    // If contour detection was enabled:
    val leftEyeContour = face.getContour(FirebaseVisionFaceContour.LEFT_EYE).points
    val upperLipBottomContour = face.getContour(FirebaseVisionFaceContour.UPPER_LIP_BOTTOM).points

    // If classification was enabled:
    if (face.smilingProbability != FirebaseVisionFace.UNCOMPUTED_PROBABILITY) {
        val smileProb = face.smilingProbability
    }
    if (face.rightEyeOpenProbability != FirebaseVisionFace.UNCOMPUTED_PROBABILITY) {
        val rightEyeOpenProb = face.rightEyeOpenProbability
    }

    // If face tracking was enabled:
    if (face.trackingId != FirebaseVisionFace.INVALID_ID) {
        val id = face.trackingId
    }
}

Esempio di contorni del viso

Quando il rilevamento del contorno del viso è attivo, viene visualizzato un elenco di punti per ogni tratto del viso rilevato. Questi punti rappresentano la forma funzionalità. Per informazioni dettagliate su come vengono rappresentati i contorni, consulta la Panoramica dei concetti di rilevamento dei volti.

La seguente immagine mostra come questi punti mappano a un volto (fai clic sull'icona immagine da ingrandire):

Rilevamento dei volti in tempo reale

Se vuoi utilizzare il rilevamento dei volti in un'applicazione in tempo reale, segui queste istruzioni linee guida per ottenere le migliori frequenze fotogrammi:

  • Configura il rilevatore di volti in modo che utilizzi uno dei seguenti metodi: rilevamento o classificazione del contorno del volto e rilevamento dei punti di riferimento, ma non entrambi:

    Rilevamento contorno
    Rilevamento dei punti di riferimento
    Classificazione
    Rilevamento e classificazione dei punti di riferimento
    Rilevamento dei contorni e dei punti di riferimento
    Rilevamento e classificazione del contorno
    Rilevamento contorni, rilevamento dei punti di riferimento e classificazione

  • Attiva la modalità FAST (attivata per impostazione predefinita).

  • Prova ad acquisire immagini a una risoluzione inferiore. Tuttavia, tieni presente requisiti per le dimensioni immagine di questa API.

  • Limita le chiamate al rilevatore. Se un nuovo fotogramma disponibili mentre il rilevatore è in esecuzione, abbandona il frame.
  • Se utilizzi l'output del rilevatore per sovrapporre gli elementi grafici l'immagine di input, occorre prima ottenere il risultato da ML Kit, quindi eseguire il rendering dell'immagine e la sovrapposizione in un solo passaggio. In questo modo, puoi visualizzare i contenuti solo una volta per ogni frame di input.

  • Se utilizzi l'API Camera2, acquisisci le immagini in formato ImageFormat.YUV_420_888.

    Se usi l'API Camera precedente, acquisisci le immagini in Formato ImageFormat.NV21.