זיהוי פרטים של 'רשת פנים' באמצעות ML Kit ב-Android

ה-API הזה מוצע בגרסת בטא, והוא לא כפוף להסכם רמת שירות או למדיניות הוצאה משימוש. יכול להיות שיבוצעו שינויים ב-API הזה שיפגעו בתאימות לאחור.

אתם יכולים להשתמש ב-ML Kit כדי לזהות פרצופים בתמונות ובסרטונים דמויי סלפי.

ב-API הזה נעשה שימוש בספרייה בחבילה שמגדילה את גודל האפליקציה. לקבלת מידע נוסף, אפשר לעיין במדריך הזה.

API לזיהוי רשת פנים
שם ה-SDK	face-mesh-detection
הטמעה	הקוד והנכסים מקושרים באופן סטטי לאפליקציה בזמן ה-build.
ההשפעה של גודל האפליקציה	בערך 6.4MB
ביצועים	זמן אמת ברוב המכשירים.

אני רוצה לנסות

• אפשר לנסות את האפליקציה לדוגמה כדי לראות דוגמה לשימוש ב-API הזה.

לפני שמתחילים

כדי להשתמש ב-API הזה נדרש Android API ברמה 21 ומעלה. יש לוודא שקובץ ה-build של האפליקציה משתמש בערך minSdkVersion של 21 ומעלה.

1. בקובץ build.gradle ברמת הפרויקט, חשוב לכלול את מאגר Maven של Google בקטע של ה-buildscript ושל כל הפרויקטים.

2. מוסיפים את התלות של ספריית זיהוי הפנים של ML Kit לקובץ ההדרגתיות ברמת האפליקציה של המודול, שהוא בדרך כלל app/build.gradle:

   dependencies {
    // ...
   
    implementation 'com.google.mlkit:face-mesh-detection:16.0.0-beta1'
   }
   

הנחיות לבחירת תמונה לקלט

1. יש לצלם את התמונות בטווח של כ-2 מטרים ממצלמת המכשיר, כך שהפנים גדולים מספיק לזיהוי אופטימלי של רשת הפנים. באופן כללי, ככל שהפנים גדולות יותר, כך זיהוי רשת הפנים טוב יותר.

2. הפנים צריכות להיות פונות למצלמה, ולחשוף לפחות מחצית מהפנים. כל עצם גדול בין הפנים למצלמה עלול לפגוע ברמת הדיוק.

אם אתם רוצים לזהות פנים באפליקציה בזמן אמת, כדאי גם לשקול את הממדים הכוללים של תמונת הקלט. אפשר לעבד תמונות קטנות יותר מהר יותר, ולכן צילום תמונות ברזולוציות נמוכות יותר מקצר את זמן האחזור. עם זאת, חשוב לזכור את דרישות הדיוק שמפורטות למעלה ולוודא שהפנים של האדם שרוצים לצלם תופסות חלק גדול ככל האפשר מהתמונה.

הגדרה של מזהה רשת הפנים

אם רוצים לשנות את הגדרות ברירת המחדל של מזהה רשת הפנים, צריך לציין את ההגדרות האלה באמצעות אובייקט FaceMeshDetectorOptions. אפשר לשנות את ההגדרות הבאות:

1. setUseCase

   • BOUNDING_BOX_ONLY: מספקת תיבה תוחמת רק עבור רשת פנים שזוהתה. זהו מזהה הפנים המהיר ביותר, אבל הוא מוגבל לטווח(הפנים חייבות להיות בטווח של כ-2 מטרים או כ-2 מטרים מהמצלמה).

   • FACE_MESH (אפשרות ברירת המחדל): מספקת תיבה תוחמת (bounding box) ומידע נוסף על רשת הפנים (468 נקודות בתלת-ממד ופרטי משולש). בהשוואה לתרחיש לדוגמה של BOUNDING_BOX_ONLY, זמן האחזור עולה בכ-15%, כפי שנמדד ב-Pixel 3.

למשל:

Kotlin

val defaultDetector = FaceMeshDetection.getClient(
  FaceMeshDetectorOptions.DEFAULT_OPTIONS)

val boundingBoxDetector = FaceMeshDetection.getClient(
  FaceMeshDetectorOptions.Builder()
    .setUseCase(UseCase.BOUNDING_BOX_ONLY)
    .build()
)

Java

FaceMeshDetector defaultDetector =
        FaceMeshDetection.getClient(
                FaceMeshDetectorOptions.DEFAULT_OPTIONS);

FaceMeshDetector boundingBoxDetector = FaceMeshDetection.getClient(
        new FaceMeshDetectorOptions.Builder()
                .setUseCase(UseCase.BOUNDING_BOX_ONLY)
                .build()
        );

הכנת תמונת הקלט

על מנת לזהות פנים בתמונה, צריך ליצור אובייקט InputImage מ-Bitmap, מ-media.Image, מ-ByteBuffer, ממערך בייטים או מקובץ במכשיר. לאחר מכן, מעבירים את האובייקט InputImage ל-method process של FaceDetector.

לזיהוי רשת פנים, צריך להשתמש בתמונה במידות של 480x360 פיקסלים לפחות. אם אתם מזהים פנים בזמן אמת, צילום פריימים ברזולוציה המינימלית הזו יכול לעזור לכם לקצר את זמן האחזור.

ניתן ליצור אובייקט InputImage ממקורות שונים. בהמשך מוסבר על כל אחד מהם.

באמצעות media.Image

כדי ליצור אובייקט InputImage מאובייקט media.Image, למשל כשמצלמים תמונה ממצלמת המכשיר, צריך להעביר את האובייקט media.Image ואת הסיבוב של התמונה אל InputImage.fromMediaImage().

אם משתמשים בספריית CameraX, המחלקות OnImageCapturedListener ו-ImageAnalysis.Analyzer מחשבים את ערך הסיבוב בשבילכם.

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

אם לא משתמשים בספריית מצלמה כדי לקבל את מידת הסיבוב של התמונה, אפשר לחשב אותה לפי מידת הסיבוב של המכשיר והכיוון של חיישן המצלמה במכשיר:

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

לאחר מכן מעבירים את האובייקט media.Image ואת ערך מעלה הסיבוב ל-InputImage.fromMediaImage():

Kotlin

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

Java

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

שימוש ב-URI של קובץ

כדי ליצור אובייקט InputImage מ-URI של קובץ, מעבירים את ההקשר של האפליקציה ואת ה-URI של הקובץ אל InputImage.fromFilePath(). האפשרות הזו שימושית כשמשתמשים ב-Intent של ACTION_GET_CONTENT כדי לבקש מהמשתמשים לבחור תמונה מאפליקציית הגלריה.

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

באמצעות ByteBuffer או ByteArray

כדי ליצור אובייקט InputImage מ-ByteBuffer או מ-ByteArray, קודם צריך לחשב את מעלות סיבוב התמונה כפי שתואר קודם עבור קלט media.Image. לאחר מכן יוצרים את האובייקט InputImage עם מאגר הנתונים הזמני או המערך, יחד עם הגובה, הרוחב, פורמט קידוד הצבע ומידת הסיבוב של התמונה:

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

באמצעות Bitmap

כדי ליצור אובייקט InputImage מאובייקט Bitmap, צריך להשתמש בהצהרה הבאה:

Kotlin

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

Java

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

התמונה מיוצגת על ידי אובייקט Bitmap יחד עם מעלות סיבוב.

עיבוד התמונה

מעבירים את התמונה ל-method process:

Kotlin

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

Java

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

קבלת מידע על רשת הפנים שזוהתה

אם זוהו פנים בתמונה, רשימה של FaceMesh אובייקטים מועברת למאזין המוצלח. כל FaceMesh מייצג פנים שזוהו בתמונה. בכל רשת פנים אפשר לקבל את הקואורדינטות התוחמות שלה בתמונת הקלט, וגם כל מידע אחר שהגדרתם בחיישן הרשת לזיהוי פנים.

Kotlin

for (faceMesh in faceMeshs) {
    val bounds: Rect = faceMesh.boundingBox()

    // Gets all points
    val faceMeshpoints = faceMesh.allPoints
    for (faceMeshpoint in faceMeshpoints) {
      val index: Int = faceMeshpoints.index()
      val position = faceMeshpoint.position
    }

    // Gets triangle info
    val triangles: List<Triangle<FaceMeshPoint>> = faceMesh.allTriangles
    for (triangle in triangles) {
      // 3 Points connecting to each other and representing a triangle area.
      val connectedPoints = triangle.allPoints()
    }
}

Java

for (FaceMesh faceMesh : faceMeshs) {
    Rect bounds = faceMesh.getBoundingBox();

    // Gets all points
    List<FaceMeshPoint> faceMeshpoints = faceMesh.getAllPoints();
    for (FaceMeshPoint faceMeshpoint : faceMeshpoints) {
        int index = faceMeshpoints.getIndex();
        PointF3D position = faceMeshpoint.getPosition();
    }

    // Gets triangle info
    List<Triangle<FaceMeshPoint>> triangles = faceMesh.getAllTriangles();
    for (Triangle<FaceMeshPoint> triangle : triangles) {
        // 3 Points connecting to each other and representing a triangle area.
        List<FaceMeshPoint> connectedPoints = triangle.getAllPoints();
    }
}