Wykrywanie twarzy za pomocą ML Kit na Androidzie

Za pomocą pakietu ML Kit możesz wykrywać twarze na obrazach i w filmach.

Ten interfejs API jest dostępny za pomocą biblioteki niepołączonej, którą należy pobrać przed użyciem, lub biblioteka w pakiecie, która zwiększa rozmiar aplikacji. Zobacz tym przewodniku, by dowiedzieć się więcej o różnicach między 2 opcjami instalacji.

Funkcja	Niegrupowane	Łączenie w pakiety
Implementacja	Model jest pobierany dynamicznie przez Usługi Google Play.	Model jest statycznie połączony z aplikacją w momencie kompilacji.
Rozmiar aplikacji	Zwiększenie rozmiaru o około 800 KB.	Zwiększenie rozmiaru o około 6,9 MB.
Czas inicjowania	Przed jego pierwszym użyciem konieczne może być poczekać na pobranie modelu.	Model jest dostępny od razu

Wypróbuj

• Wypróbuj przykładową aplikację, aby: zobaczysz przykład użycia tego interfejsu API.
• Wypróbuj kod samodzielnie za pomocą

Zanim zaczniesz

Ten interfejs API wymaga interfejsu API Androida na poziomie 21 lub wyższym. Upewnij się, że kompilacja aplikacji ma wartość minSdkVersion równą 21 lub większą.

1. W pliku build.gradle na poziomie projektu uwzględnij parametr Google Repozytorium Maven w sekcjach buildscript i allprojects.

2. Dodaj zależności bibliotek ML Kit na Androida do biblioteki modułu pliku Gradle na poziomie aplikacji, który zwykle ma wartość app/build.gradle. Wybierz jedną z opcji: następujące zależności w zależności od potrzeb:

   Aby połączyć model z aplikacją:

   dependencies {
     // ...
     // Use this dependency to bundle the model with your app
     implementation 'com.google.mlkit:face-detection:16.1.7'
   }
   

   Aby używać modelu w Usługach Google Play:

   dependencies {
     // ...
     // Use this dependency to use the dynamically downloaded model in Google Play Services
     implementation 'com.google.android.gms:play-services-mlkit-face-detection:17.1.0'
   }
   

3. Jeśli zdecydujesz się używać modelu w Usługach Google Play, możesz skonfigurować aplikacja automatycznie pobiera model na urządzenie, ze Sklepu Play. Aby to zrobić, dodaj następującą deklarację do plik AndroidManifest.xml Twojej aplikacji:

   <application ...>
         ...
         <meta-data
             android:name="com.google.mlkit.vision.DEPENDENCIES"
             android:value="face" >
         <!-- To use multiple models: android:value="face,model2,model3" -->
   </application>
   

   Możesz też bezpośrednio sprawdzić dostępność modelu i poprosić o pobranie go Interfejs ModuleInstallClient API Usług Google Play.

   Jeśli nie włączysz pobierania modelu w czasie instalacji lub nie poprosisz o pobieranie dla pełnoletnich, model jest pobierany przy pierwszym uruchomieniu wzorca. Twoje prośby przed zakończeniem pobierania nie przyniosą żadnych wyników.

Wytyczne dotyczące obrazu wejściowego

Do rozpoznawania twarzy należy użyć obrazu o wymiarach co najmniej 480 x 360 pikseli. Aby ML Kit mógł precyzyjnie wykrywać twarze, obrazy wejściowe muszą zawierać twarze które są reprezentowane przez wystarczającą ilość danych pikseli. Ogólnie rzecz biorąc, każda twarz, którą chcesz pokazać, powinna mieć rozmiar co najmniej 100 x 100 pikseli. Jeśli chcesz wykrywać aby określić kontury twarzy, ML Kit wymaga wyższej rozdzielczości: powinien wynosić co najmniej 200 x 200 pikseli.

Jeśli wykrywasz twarze w aplikacji działającej w czasie rzeczywistym, możesz też aby wziąć pod uwagę ogólne wymiary obrazów wejściowych. Mniejsze obrazy szybsze przetwarzanie. Aby zmniejszyć opóźnienia, rób zdjęcia w niższej rozdzielczości, pamiętaj o powyższych wymaganiach dotyczących dokładności i upewnij się, twarz obiektu zajmuje jak najwięcej miejsca na obrazie. Zobacz też wskazówkami na temat poprawy skuteczności w czasie rzeczywistym.

Słaba ostrość obrazu również może mieć wpływ na dokładność. Jeśli nie otrzymasz akceptacji poproś użytkownika o powtórzenie zdjęcia.

Położenie twarzy w odniesieniu do aparatu może też wpływać na jej wygląd. wykrywanych przez ML Kit. Zobacz Pojęcia związane z wykrywaniem twarzy.

1. Konfigurowanie wykrywania twarzy

Zanim zastosujesz wykrywanie twarzy na zdjęciu, możesz zmienić domyślnych ustawień wykrywania twarzy, określ je za pomocą FaceDetectorOptions. Można zmienić następujące ustawienia:

Ustawienia
setPerformanceMode	PERFORMANCE_MODE_FAST (domyślna) | . PERFORMANCE_MODE_ACCURATE Większa szybkość lub dokładność podczas wykrywania twarzy.
setLandmarkMode	LANDMARK_MODE_NONE (domyślna) | . LANDMARK_MODE_ALL Określa, czy rozpoznać „punkty orientacyjne” twarzy: oczy, uszy, nos, policzki, usta itd.
setContourMode	CONTOUR_MODE_NONE (domyślna) | . CONTOUR_MODE_ALL Określa, czy wykrywać kontury rysów twarzy. Kontury są tylko dla najbardziej widocznej twarzy na zdjęciu.
setClassificationMode	CLASSIFICATION_MODE_NONE (domyślna) | . CLASSIFICATION_MODE_ALL Możliwość sklasyfikowania twarzy w kategoriach, takich jak „uśmiech”, i „oczy otwarte”.
setMinFaceSize	float (domyślnie: 0.1f) Ustawia najmniejszy wymagany rozmiar twarzy, wyrażony jako współczynnik od szerokości głowy do szerokości obrazu.
enableTracking	false (domyślna) | true Określa, czy przypisywać twarzom identyfikator, który może służyć do śledzenia i twarze na zdjęciach. Pamiętaj, że przy włączonym wykrywaniu kontur tylko jedna twarz więc śledzenie twarzy nie da żadnych przydatnych wyników. Do tego celu i aby zwiększyć szybkość wykrywania, nie włączaj obu konturów wykrywaniem oraz śledzeniem twarzy.

Na przykład:

Kotlin

// High-accuracy landmark detection and face classification
val highAccuracyOpts = FaceDetectorOptions.Builder()
        .setPerformanceMode(FaceDetectorOptions.PERFORMANCE_MODE_ACCURATE)
        .setLandmarkMode(FaceDetectorOptions.LANDMARK_MODE_ALL)
        .setClassificationMode(FaceDetectorOptions.CLASSIFICATION_MODE_ALL)
        .build()

// Real-time contour detection
val realTimeOpts = FaceDetectorOptions.Builder()
        .setContourMode(FaceDetectorOptions.CONTOUR_MODE_ALL)
        .build()
FaceDetectionActivity.kt

Java

// High-accuracy landmark detection and face classification
FaceDetectorOptions highAccuracyOpts =
        new FaceDetectorOptions.Builder()
                .setPerformanceMode(FaceDetectorOptions.PERFORMANCE_MODE_ACCURATE)
                .setLandmarkMode(FaceDetectorOptions.LANDMARK_MODE_ALL)
                .setClassificationMode(FaceDetectorOptions.CLASSIFICATION_MODE_ALL)
                .build();

// Real-time contour detection
FaceDetectorOptions realTimeOpts =
        new FaceDetectorOptions.Builder()
                .setContourMode(FaceDetectorOptions.CONTOUR_MODE_ALL)
                .build();
FaceDetectionActivity.java

2. Przygotowywanie obrazu wejściowego

Aby wykrywać twarze na obrazie, utwórz obiekt InputImage z obiektu Bitmap, media.Image, ByteBuffer, tablicy bajtów lub pliku w urządzenia. Następnie przekaż obiekt InputImage do funkcji Metoda process użytkownika FaceDetector.

Wykrywanie twarzy wymaga użycia zdjęcia o wymiarach co najmniej 480 x 360 pikseli. Jeśli wykrywasz twarze w czasie rzeczywistym i rejestrujesz klatki, przy minimalnej rozdzielczości może pomóc zmniejszyć opóźnienie.

Możesz utworzyć InputImage z różnych źródeł, każdy z nich objaśniamy poniżej.

Korzystanie z: media.Image

Aby utworzyć InputImage z obiektu media.Image, np. podczas przechwytywania obrazu z z aparatu urządzenia, przekaż obiekt media.Image i obiekt obrazu w kierunku InputImage.fromMediaImage().

Jeśli używasz tagu CameraX, OnImageCapturedListener oraz ImageAnalysis.Analyzer klasy obliczają wartość rotacji dla Ciebie.

Kotlin

private class YourImageAnalyzer : ImageAnalysis.Analyzer {

    override fun analyze(imageProxy: ImageProxy) {
        val mediaImage = imageProxy.image
        if (mediaImage != null) {
            val image = InputImage.fromMediaImage(mediaImage, imageProxy.imageInfo.rotationDegrees)
            // Pass image to an ML Kit Vision API
            // ...
        }
    }
}

Java

private class YourAnalyzer implements ImageAnalysis.Analyzer {

    @Override
    public void analyze(ImageProxy imageProxy) {
        Image mediaImage = imageProxy.getImage();
        if (mediaImage != null) {
          InputImage image =
                InputImage.fromMediaImage(mediaImage, imageProxy.getImageInfo().getRotationDegrees());
          // Pass image to an ML Kit Vision API
          // ...
        }
    }
}

Jeśli nie korzystasz z biblioteki aparatu, która określa kąt obrotu obrazu, może go obliczyć na podstawie stopnia obrotu urządzenia i orientacji aparatu czujnik w urządzeniu:

Kotlin

private val ORIENTATIONS = SparseIntArray()

init {
    ORIENTATIONS.append(Surface.ROTATION_0, 0)
    ORIENTATIONS.append(Surface.ROTATION_90, 90)
    ORIENTATIONS.append(Surface.ROTATION_180, 180)
    ORIENTATIONS.append(Surface.ROTATION_270, 270)
}

/**
 * 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, isFrontFacing: Boolean): 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)

    // Get the device's sensor orientation.
    val cameraManager = activity.getSystemService(CAMERA_SERVICE) as CameraManager
    val sensorOrientation = cameraManager
            .getCameraCharacteristics(cameraId)
            .get(CameraCharacteristics.SENSOR_ORIENTATION)!!

    if (isFrontFacing) {
        rotationCompensation = (sensorOrientation + rotationCompensation) % 360
    } else { // back-facing
        rotationCompensation = (sensorOrientation - rotationCompensation + 360) % 360
    }
    return rotationCompensation
}
MLKitVisionImage.kt

Java

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

/**
 * 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, boolean isFrontFacing)
        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);

    // Get the device's sensor orientation.
    CameraManager cameraManager = (CameraManager) activity.getSystemService(CAMERA_SERVICE);
    int sensorOrientation = cameraManager
            .getCameraCharacteristics(cameraId)
            .get(CameraCharacteristics.SENSOR_ORIENTATION);

    if (isFrontFacing) {
        rotationCompensation = (sensorOrientation + rotationCompensation) % 360;
    } else { // back-facing
        rotationCompensation = (sensorOrientation - rotationCompensation + 360) % 360;
    }
    return rotationCompensation;
}

Następnie przekaż obiekt media.Image oraz wartość stopnia obrotu na InputImage.fromMediaImage():

Kotlin

val image = InputImage.fromMediaImage(mediaImage, rotation)
MLKitVisionImage.kt

Java

InputImage image = InputImage.fromMediaImage(mediaImage, rotation);

Za pomocą identyfikatora URI pliku

Aby utworzyć InputImage obiektu z identyfikatora URI pliku, przekaż kontekst aplikacji oraz identyfikator URI pliku do InputImage.fromFilePath() Jest to przydatne, gdy użyj intencji ACTION_GET_CONTENT, aby zachęcić użytkownika do wyboru obraz z aplikacji Galeria.

Kotlin

val image: InputImage
try {
    image = InputImage.fromFilePath(context, uri)
} catch (e: IOException) {
    e.printStackTrace()
}
MLKitVisionImage.kt

Java

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

Przy użyciu: ByteBuffer lub ByteArray

Aby utworzyć InputImage obiektu z ByteBuffer lub ByteArray, najpierw oblicz wartość obrazu stopień obrotu zgodnie z wcześniejszym opisem dla danych wejściowych media.Image. Następnie utwórz obiekt InputImage z buforem lub tablicą oraz wysokość, szerokość, format kodowania kolorów i stopień obrotu:

Kotlin

val image = InputImage.fromByteBuffer(
        byteBuffer,
        /* image width */ 480,
        /* image height */ 360,
        rotationDegrees,
        InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12
)
MLKitVisionImage.kt
// Or:
val image = InputImage.fromByteArray(
        byteArray,
        /* image width */ 480,
        /* image height */ 360,
        rotationDegrees,
        InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12
)
MLKitVisionImage.kt

Java

InputImage image = InputImage.fromByteBuffer(byteBuffer,
        /* image width */ 480,
        /* image height */ 360,
        rotationDegrees,
        InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12
);
MLKitVisionImage.java
// Or:
InputImage image = InputImage.fromByteArray(
        byteArray,
        /* image width */480,
        /* image height */360,
        rotation,
        InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12
);
MLKitVisionImage.java

Korzystanie z: Bitmap

Aby utworzyć InputImage z obiektu Bitmap, wypełnij tę deklarację:

Kotlin

val image = InputImage.fromBitmap(bitmap, 0)
MLKitVisionImage.kt

Java

InputImage image = InputImage.fromBitmap(bitmap, rotationDegree);
MLKitVisionImage.java

Obraz jest reprezentowany przez obiekt Bitmap wraz z informacją o obróceniu w stopniach.

3. Pobieranie instancji FaceDetector

Kotlin

val detector = FaceDetection.getClient(options)
// Or, to use the default option:
// val detector = FaceDetection.getClient();
FaceDetectionActivity.kt

Java

FaceDetector detector = FaceDetection.getClient(options);
// Or use the default options:
// FaceDetector detector = FaceDetection.getClient();
FaceDetectionActivity.java

4. Przetwarzanie zdjęcia

Przekaż obraz do metody process:

Kotlin

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

Java

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

Uwaga: jeśli używasz CameraX API, pamiętaj, aby zamknąć ImageProxy, gdy skończysz z niego korzystać. np. przez dodanie OnCompleteListener do elementu Task zwróconego przez Metoda process. Zobacz VisionProcessorBase w przykładowej aplikacji z krótkim wprowadzeniem.

5. Uzyskiwanie informacji o wykrytych twarzy

Jeśli wykrywanie twarzy się powiedzie, zobaczysz listę Face obiektów zostało przekazanych do powodzenia słuchacz. Każdy obiekt Face reprezentuje twarz, która została wykryta zdjęcia. W przypadku każdej płaszczyzny można uzyskać współrzędne ograniczające dla każdej płaszczyzny oraz wszelkie inne informacje, na które skonfigurowano wykrywanie twarzy znaleźć. Na przykład:

Kotlin

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(FaceLandmark.LEFT_EAR)
    leftEar?.let {
        val leftEarPos = leftEar.position
    }

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

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

    // If face tracking was enabled:
    if (face.trackingId != null) {
        val id = face.trackingId
    }
}
FaceDetectionActivity.kt

Java

for (Face 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):
    FaceLandmark leftEar = face.getLandmark(FaceLandmark.LEFT_EAR);
    if (leftEar != null) {
        PointF leftEarPos = leftEar.getPosition();
    }

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

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

    // If face tracking was enabled:
    if (face.getTrackingId() != null) {
        int id = face.getTrackingId();
    }
}
FaceDetectionActivity.java

Przykład konturu twarzy

Gdy włączysz wykrywanie konturu twarzy, zobaczysz listę punktów za wszystkie wykryte cechy twarzy. Te punkty odpowiadają kształtowi funkcji. Zobacz Twarz Pojęcia związane z wykrywaniem, aby uzyskać szczegółowe informacje o konturach reprezentowanych.

Poniższy obraz przedstawia sposób, w jaki punkty są odwzorowywane na twarz, kliknij obraz, aby go powiększyć:

Wykrywanie twarzy w czasie rzeczywistym

Jeśli chcesz używać wykrywania twarzy w aplikacjach działających w czasie rzeczywistym, postępuj zgodnie z tymi instrukcjami wytycznych dotyczących uzyskiwania najlepszej liczby klatek na sekundę:

• Skonfiguruj wykrywacz twarzy, aby używał jednego wykrywanie kontur lub klasyfikacja twarzy i wykrywanie punktów orientacyjnych, ale nie oba te rodzaje naraz:

  Wykrywanie konturów
  Wykrywanie punktów orientacyjnych
  Klasyfikacja
  Wykrywanie i klasyfikacja punktów orientacyjnych
  Wykrywanie konturów i wykrywanie punktów orientacyjnych
  Wykrywanie i klasyfikacja kontur
  Wykrywanie konturów, wykrywanie punktów orientacyjnych i klasyfikacja
  

• Włącz tryb FAST (domyślnie włączony).

• Rozważ robienie zdjęć w niższej rozdzielczości. Pamiętaj jednak, wymagania dotyczące wymiarów obrazów w tym interfejsie API.

Jeśli używasz tagu Camera lub camera2 API, ograniczanie wywołań detektora. Jeśli nowy film ramka stanie się dostępna, gdy detektor będzie aktywny, upuść ją. Zobacz VisionProcessorBase w przykładowej aplikacji z krótkim wprowadzeniem.

Jeśli używasz interfejsu API CameraX, upewnij się, że strategia obciążenia wstecznego jest ustawiona na wartość domyślną . ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST Gwarantuje to, że do analizy zostanie dostarczony tylko 1 obraz naraz. Jeśli więcej obrazów generowane, gdy analizator jest zajęty, są usuwane automatycznie i nie są umieszczane w kolejce . Po zamknięciu analizowanego obrazu przez wywołanie ImageProxy.close(), zostanie wyświetlony następny najnowszy obraz.

Jeśli użyjesz danych wyjściowych detektora do nakładania grafiki na obrazu wejściowego, najpierw pobierz wynik z ML Kit, a następnie wyrenderuj obraz i nakładanie nakładek w jednym kroku. Powoduje to wyrenderowanie na powierzchni wyświetlania tylko raz na każdą ramkę wejściową. Zobacz CameraSourcePreview i . GraphicOverlay w przykładowej aplikacji z krótkim wprowadzeniem.

Jeśli korzystasz z interfejsu API Camera2, rób zdjęcia w Format: ImageFormat.YUV_420_888. Jeśli używasz starszej wersji interfejsu Camera API, rób zdjęcia w Format: ImageFormat.NV21.