Android'de ML Kit ile yüzleri algılama

Resimler ve videodaki yüzleri algılamak için ML Kit'i kullanabilirsiniz.

Deneyin

• Bu örnek API'yi görmek için örnek uygulamayı inceleyin.
• Kodu codelab ile kendiniz deneyin.

Başlamadan önce

1. Proje düzeyindeki build.gradle dosyanıza Google'ın Maven deposunu hem buildscript hem de allprojects bölümlerine eklediğinizden emin olun.

2. ML Kit Android kitaplıklarının bağımlılıklarını, modülünüzün genellikle app/build.gradle olan gradle dosyasına ekleyin. İhtiyaçlarınıza bağlı olarak aşağıdaki bağımlılıklardan birini seçin:

   Modeli uygulamanızla birlikte gruplandırmak için:

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

   Modeli Google Play Hizmetleri'nde kullanmak için:

   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. Modeli Google Play Hizmetleri'nde kullanmayı seçerseniz uygulamanızı Play Store'dan yüklendikten sonra, modeli cihaza otomatik olarak indirecek şekilde yapılandırabilirsiniz. Bunu yapmak için uygulamanızın AndroidManifest.xml dosyasına aşağıdaki beyanı ekleyin:

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

   Ayrıca, modelin kullanılabilirliğini açıkça kontrol edebilir ve Google Play Hizmetleri ModuleInstallClient API üzerinden indirme isteğinde bulunabilirsiniz.

   Yükleme zamanı model indirmelerini etkinleştirmez veya açık indirme isteğinde bulunmazsanız, model, algılayıcıyı ilk kez çalıştırdığınızda indirilir. İndirme tamamlanmadan önce yaptığınız istekler hiçbir sonuç vermez.

Giriş resmi kuralları

Yüz tanıma için en az 480x360 piksel boyutunda bir resim kullanmanız gerekir. ML Kit'in yüzleri doğru şekilde algılaması için giriş resimleri yeterli piksel verisi ile temsil edilen yüzler içermelidir. Genel olarak, bir resimde algılamak istediğiniz her yüz en az 100x100 piksel olmalıdır. Yüzlerin dış çizgilerini algılamak istiyorsanız ML Kiti daha yüksek çözünürlük girişi gerektirir: Her yüz en az 200x200 piksel olmalıdır.

Yüzleri gerçek zamanlı bir uygulamada tespit ederseniz giriş resimlerinin genel boyutlarını da değerlendirmek isteyebilirsiniz. Küçük resimler daha hızlı işlenebilir. Bu nedenle, gecikmeyi azaltmak için daha düşük çözünürlüklerde resimler yakalayın. Ancak, yukarıdaki doğruluk gereksinimlerini göz önünde bulundurun ve öznenin yüzünün resmin olabildiğince çok yer kaplamasını sağlayın. Ayrıca gerçek zamanlı performansı iyileştirmek için ipuçlarına bakın.

Yetersiz resim odağı da doğruluğu etkileyebilir. Kabul edilebilir sonuçlar elde etmezseniz kullanıcıdan görseli tekrar çekmesini isteyin.

Bir yüzün kameraya göre yönü de ML Kit'in algıladığı yüz özelliklerini etkileyebilir. Yüz Algılama Kavramları sayfasını inceleyin.

1. Yüz algılayıcıyı yapılandırma

Örneğin:

// 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

// 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. Giriş resmini hazırlama

Yüz algılama için en az 480x360 piksel boyutunda bir resim kullanmanız gerekir. Yüzleri gerçek zamanlı olarak algılıyorsanız kareleri bu minimum çözünürlükte yakalamak gecikmeyi azaltmaya yardımcı olabilir.

Farklı kaynaklardan bir InputImage nesnesi oluşturabilirsiniz. Her nesne aşağıda açıklanmıştır.

media.Image kullanarak

Bir cihazın kamerasından resim çekerken olduğu gibi bir media.Image nesnesinden InputImage nesnesi oluşturmak için media.Image nesnesini ve resmin rotasyonunu InputImage.fromMediaImage() öğesine iletin.

KameraX kitaplığını kullanırsanız OnImageCapturedListener ve ImageAnalysis.Analyzer sınıfları sizin için rotasyon değerini hesaplar.

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
            // ...
        }
    }
}

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
          // ...
        }
    }
}

Resmin döndürme derecesini veren bir kamera kitaplığı kullanmıyorsanız bunu, cihazın döndürme derecesinden ve kamera kamerasının yönüne göre hesaplayabilirsiniz:

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

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;
}

Ardından media.Image nesnesini ve döndürme derecesi değerini InputImage.fromMediaImage() öğesine iletin:

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

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

Dosya URI'sı kullanma

Dosya URI'sinden InputImage nesnesi oluşturmak için uygulama bağlamını ve dosya URI'sini InputImage.fromFilePath() öğesine iletin. Bu, kullanıcıya galeri uygulamasından bir resim seçmesini istemek için ACTION_GET_CONTENT amacı kullandığınızda yararlıdır.

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

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

ByteBuffer veya ByteArray kullanarak

ByteBuffer veya ByteArray öğesinden InputImage nesnesi oluşturmak için önce resim döndürme derecesini media.Image girişi için daha önce açıklandığı şekilde hesaplayın. Ardından; arabellek veya diziyle birlikte resmin yüksekliğini, genişliğini, renk kodlama biçimini ve döndürme derecesini kullanarak InputImage nesnesi oluşturun:

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

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

Bitmap kullanarak

Bitmap nesnesinden InputImage nesnesi oluşturmak için aşağıdaki ifadeyi yazın:

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

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

Resim, döndürme dereceleriyle birlikte bir Bitmap nesnesiyle gösterilir.

3. FaceDetector örneğini alma

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

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

4. Resmi işleyin

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

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

5. Algılanan yüzler hakkında bilgi alın

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

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

Yüz konturu örneği

Yüz konturu algılaması etkinleştirildiğinde, algılanan her yüz özelliği için bir nokta listesi alırsınız. Bu noktalar özelliğin şeklini temsil eder. Konturların nasıl temsil edildiğiyle ilgili ayrıntılar için Yüz Algılama Kavramları bölümüne bakın.

Aşağıdaki resimde bu noktanın bir yüz ile nasıl eşleştiği gösterilmiştir. Büyütmek için resmi tıklayın: