דף זה תורגם על ידי 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 לקובץ ההדרגתיות של המודול ברמת האפליקציה, שהוא בדרך כלל 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() כדי לברר את גודל המסכה כשמפעילים את האפשרות הזו.

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

ציון אפשרויות הפילוח:

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 המוכן לשיטה 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 שמוחזר מ-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 הזה.
כדאי להפעיל את האפשרות 'מסכה בגודל RAW' ולשלב את כל הלוגיקה של שינוי קנה המידה יחד. לדוגמה, במקום לאפשר ל-API לשנות את קנה המידה של המסכה כך שתתאים לגודל של תמונת הקלט תחילה, ולאחר מכן לשנות את קנה המידה שלה שוב כך שיתאים לגודל התצוגה של התצוגה, פשוט מבקשים את המסכה בגודל הגולמי, ומשלבים את שני השלבים האלה בפעולה אחת.
אם משתמשים ב-API של Camera או camera2, אפשר לווסת קריאות לגלאי. אם מתפנה פריים חדש של וידאו בזמן שהמזהה פועל, צריך לשחרר אותו. כדי לראות דוגמה, אפשר לעיין בכיתה VisionProcessorBase באפליקציה לדוגמה של המדריך למתחילים.
אם אתם משתמשים ב-CameraX API, חשוב לוודא ששיטת הלחץ הזמני מוגדרת לערך ברירת המחדל שלה 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`