דף זה תורגם על ידי Cloud Translation API.

פילוח תמונת סלפי באמצעות ML Kit ב-Android

ML Kit מספק SDK מותאם לסגמנטציה של תמונות סלפי.

הנכסים של פילוח הסלפי מקושרים באופן סטטי לאפליקציה בזמן ה-build. הפעולה הזו תגדיל את גודל ההורדה של האפליקציה ב-4.5MB, וזמן האחזור של ה-API עשוי להשתנות מ-25 אלפיות השנייה ל-65 אלפיות השנייה, בהתאם לגודל של תמונת הקלט, כפי שנמדד ב-Pixel 4.

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

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

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

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

בקובץ build.gradle ברמת הפרויקט, חשוב לכלול את מאגר Maven של Google בקטע buildscript וגם בקטע allprojects.
מוסיפים את יחסי התלות של ספריות ML Kit Android לקובץ GRid ברמת האפליקציה של המודול, שהוא בדרך כלל app/build.gradle:

dependencies {
  implementation 'com.google.mlkit:segmentation-selfie:16.0.0-beta5'
}

‫1. יוצרים מופע של כלי הפילוח

אפשרויות פילוח

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

מצב זיהוי

Segmenter פועל בשני מצבים. חשוב לבחור את השיטה שמתאימה לתרחיש לדוגמה שלכם.

STREAM_MODE (default)

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

SINGLE_IMAGE_MODE

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

הפעלת מסכת גודל גולמי

מבקשת מהפלח להחזיר את מסיכת הגודל הגולמית שתואמת לגודל הפלט של המודל.

גודל המסכה הגולמית (למשל 256x256) קטן בדרך כלל מגודל הקלט של תמונת הקלט. יש להתקשר אל SegmentationMask#getWidth() ואל SegmentationMask#getHeight() כדי לקבל את גודל המסכה כשמפעילים את האפשרות הזו.

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

מציינים את אפשרויות הפילוח:

Kotlin

val options =
        SelfieSegmenterOptions.Builder()
            .setDetectorMode(SelfieSegmenterOptions.STREAM_MODE)
            .enableRawSizeMask()
            .build()

Java

SelfieSegmenterOptions options =
        new SelfieSegmenterOptions.Builder()
            .setDetectorMode(SelfieSegmenterOptions.STREAM_MODE)
            .enableRawSizeMask()
            .build();

יוצרים מכונה של Segmenter. מעבירים את האפשרויות שציינתם:

Kotlin

val segmenter = Segmentation.getClient(options)

Java

Segmenter segmenter = Segmentation.getClient(options);

‫2. הכנת תמונת הקלט

כדי לבצע סגמנטציה בתמונה, צריך ליצור אובייקט InputImage מ-Bitmap, media.Image, ByteBuffer, ממערך בייטים או מקובץ במכשיר.

אפשר ליצור אובייקט 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 ביחד עם מעלות סיבוב.

3. עיבוד התמונה

מעבירים את האובייקט InputImage המוכן ל-method process של Segmenter.

Kotlin

Task<SegmentationMask> result = segmenter.process(image)
       .addOnSuccessListener { results ->
           // Task completed successfully
           // ...
       }
       .addOnFailureListener { e ->
           // Task failed with an exception
           // ...
       }

Java

Task<SegmentationMask> result =
        segmenter.process(image)
                .addOnSuccessListener(
                        new OnSuccessListener<SegmentationMask>() {
                            @Override
                            public void onSuccess(SegmentationMask mask) {
                                // Task completed successfully
                                // ...
                            }
                        })
                .addOnFailureListener(
                        new OnFailureListener() {
                            @Override
                            public void onFailure(@NonNull Exception e) {
                                // Task failed with an exception
                                // ...
                            }
                        });

הערה: אם אתם משתמשים ב-API של CameraX, חשוב לסגור את ImageProxy בסיום השימוש בו, למשל על ידי הוספת OnCompleteListener אל Task שמוחזר מה-method process. תוכלו לראות דוגמה לכיתה VisionProcessorBase באפליקציה לדוגמה של המדריך למתחילים.

‫4. מקבלים את תוצאת הפילוח

אפשר לקבל את תוצאת הפילוח כך:

Kotlin

val mask = segmentationMask.getBuffer()
val maskWidth = segmentationMask.getWidth()
val maskHeight = segmentationMask.getHeight()

for (val y = 0; y < maskHeight; y++) {
  for (val x = 0; x < maskWidth; x++) {
    // Gets the confidence of the (x,y) pixel in the mask being in the foreground.
    val foregroundConfidence = mask.getFloat()
  }
}

Java

ByteBuffer mask = segmentationMask.getBuffer();
int maskWidth = segmentationMask.getWidth();
int maskHeight = segmentationMask.getHeight();

for (int y = 0; y < maskHeight; y++) {
  for (int x = 0; x < maskWidth; x++) {
    // Gets the confidence of the (x,y) pixel in the mask being in the foreground.
    float foregroundConfidence = mask.getFloat();
  }
}

דוגמה מלאה לאופן השימוש בתוצאות הפילוח מופיעה בדוגמה למתחילים של ML Kit.

טיפים לשיפור הביצועים

איכות התוצאות תלויה באיכות של תמונת הקלט:

כדי ש-ML Kit יקבל תוצאת פילוח מדויקת, התמונה צריכה להיות בגודל של לפחות 256x256 פיקסלים.
גם מיקוד תמונה לא טוב יכול להשפיע על רמת הדיוק. אם לא מתקבלות תוצאות מקובלות, מבקשים מהמשתמש לצלם מחדש את התמונה.

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

שימוש בחשבון STREAM_MODE
כדאי לצלם תמונות ברזולוציה נמוכה יותר. עם זאת, חשוב לזכור גם את הדרישות בנוגע למידות תמונה ב-API הזה.
כדאי להפעיל את האפשרות של מסכת גודל גולמית ולשלב את כל הלוגיקה של שינוי קנה מידה יחד. לדוגמה, במקום לאפשר ל-API לשנות את גודל המסכה כך שתתאים קודם לגודל תמונת הקלט, לאחר מכן תשנה את הגודל שלה שוב כך שיתאים לגודל התצוגה לתצוגה, פשוט מבקשים לבצע את מסכת הגודל הגולמי ולשלב את שני השלבים האלה לאחד.
אם משתמשים ב-API של Camera או camera2, צריך לווסת את הקריאות למזהה. אם פריים חדש בווידאו הופך לזמין בזמן שהגלאי פועל, משחררים את הפריים. לדוגמה, תוכלו לעיין בשיעור VisionProcessorBase באפליקציה לדוגמה של המדריך למתחילים.
אם משתמשים ב-API של CameraX, צריך לוודא שאסטרטגיית לחיצה לאחור מוגדרת לערך ברירת המחדל שלה ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST. כך אפשר להבטיח שרק תמונה אחת תוצג לניתוח בכל פעם. אם יופקו עוד תמונות כשהכלי לניתוח נתונים עמוס, הן יוסרו באופן אוטומטי ולא ימתינו לתור למשלוח. לאחר סגירת התמונה שמנתחת על ידי קריאה ל-ImageProxy.close(), מתקבלת התמונה העדכנית ביותר.
אם משתמשים בפלט של הגלאי כדי ליצור שכבת-על של גרפיקה בתמונת הקלט, מקבלים קודם את התוצאה מ-ML Kit ואז מעבדים את התמונה ושכבת-העל בפעולה אחת. הרינדור של משטח המסך מתבצע פעם אחת בלבד לכל מסגרת קלט. לדוגמה, אפשר לעיין בכיתות CameraSourcePreview ו- GraphicOverlay באפליקציה לדוגמה של המדריך למתחילים.
אם משתמשים ב- Camera2 API, צריך לצלם תמונות בפורמט ImageFormat.YUV_420_888. אם משתמשים בגרסה הקודמת של Camera API, צריך לצלם תמונות בפורמט ImageFormat.NV21.

פילוח תמונת סלפי באמצעות ML Kit ב-Android

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

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

‫1. יוצרים מופע של כלי הפילוח

אפשרויות פילוח

מצב זיהוי

הפעלת מסכת גודל גולמי

Kotlin

Java

Kotlin

Java

‫2. הכנת תמונת הקלט

באמצעות media.Image

Kotlin

Java

Kotlin

Java

Kotlin

Java

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

Kotlin

Java

שימוש ב-ByteBuffer או ב-ByteArray

Kotlin

Java

באמצעות Bitmap

Kotlin

Java

3. עיבוד התמונה

Kotlin

Java

‫4. מקבלים את תוצאת הפילוח

Kotlin

Java

טיפים לשיפור הביצועים

באמצעות `media.Image`

שימוש ב-`ByteBuffer` או ב-`ByteArray`

באמצעות `Bitmap`