הוספת תוויות לתמונות באמצעות מודל בהתאמה אישית ב-Android

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

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

	בחבילה	לא מקובצים
שם הספרייה	com.google.mlkit:image-labeling-custom	com.google.android.gms:play-services-mlkit-image-labeling-custom
הטמעה	הצינור מקושר באופן סטטי לאפליקציה בזמן הבנייה.	הצינור להעברת נתונים מורד באופן דינמי באמצעות Google Play Services.
גודל האפליקציה	הגודל גדל בכ-3.8MB.	הגדלה של כ-200KB.
זמן האתחול	הצינור זמין באופן מיידי.	יכול להיות שתצטרכו לחכות עד שהצינור יוריד את הנתונים לפני השימוש הראשון.
שלב במחזור החיים של ה-API	זמינות לכלל המשתמשים (GA)	בטא

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

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

מודל בחבילה	מודל מתארח
המודל הוא חלק מחבילת ה-APK של האפליקציה, ולכן הוא מגדיל את הגודל שלה.	המודל לא נכלל ב-APK. הוא מתארח על ידי העלאה ל-Cloud Storage. מומלץ להשתמש ב-Cloud Storage for Firebase.
המודל זמין באופן מיידי, גם כשמכשיר Android אופליין	האפליקציה צריכה לכלול קוד להורדת המודל לפי דרישה
אין צורך בפרויקט Firebase	נדרש פרויקט Firebase (אם משתמשים ב-Cloud Storage for Firebase).
כדי לעדכן את המודל, צריך לפרסם מחדש את האפליקציה	עדכון המודל בלי לפרסם מחדש את האפליקציה
אין בדיקות A/B מובנות	בדיקות A/B עם הגדרת תצורה מרחוק ב-Firebase

רוצה לנסות?

• אפשר לראות דוגמה לשימוש במודל החבילה באפליקציית המדריך למתחילים בנושא Vision, ודוגמה לשימוש במודל המתארח באפליקציית המדריך למתחילים בנושא AutoML.

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

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

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

   כדי לצרף את צינור הנתונים לאפליקציה:

   dependencies {
     // ...
     // Use this dependency to bundle the pipeline with your app
     implementation("com.google.mlkit:image-labeling-custom:17.0.3")
   }
   

   כדי להשתמש בצינור העיבוד ב-Google Play Services:

   dependencies {
     // ...
     // Use this dependency to use the dynamically downloaded pipeline in Google Play services
     implementation("com.google.android.gms:play-services-mlkit-image-labeling-custom:16.0.0-beta5")
   }
   

3. אם בוחרים להשתמש בצינור העברת הנתונים בשירותי Google Play, אפשר להגדיר את האפליקציה כך שהצינור יורד אוטומטית למכשיר אחרי שהאפליקציה מותקנת מחנות Play. כדי לעשות זאת, מוסיפים את ההצהרה הבאה לקובץ AndroidManifest.xml של האפליקציה:

   <application ...>
       ...
       <meta-data
           android:name="com.google.mlkit.vision.DEPENDENCIES"
           android:value="custom_ica" />
       <!-- To use multiple downloads: android:value="custom_ica,download2,download3" -->
   </application>
   

   אפשר גם לבדוק באופן מפורש את הזמינות של צינור העברת הנתונים ולבקש הורדה דרך ModuleInstallClient API של Google Play Services.

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

4. אם רוצים להוריד מודל באמצעות Cloud Storage for Firebase, צריך להוסיף את Firebase לפרויקט Android, אם עדיין לא עשיתם זאת. זה לא נדרש כשמצרפים את המודל לחבילה.

1. טעינת המודל

אפשר לטעון את המודל ממקור שצורף באופן מקומי או ממקור שמתארח מרחוק.

הגדרת מקור מודל מקומי

כדי לארוז את המודל עם האפליקציה:

1. מעתיקים את קובץ המודל (בדרך כלל מסתיים ב-.tflite או ב-.lite) לתיקייה assets/ של האפליקציה. (יכול להיות שתצטרכו ליצור את התיקייה קודם. לשם כך, לוחצים לחיצה ימנית על התיקייה app/ ואז לוחצים על חדש > תיקייה > תיקיית נכסים).

2. יוצרים אובייקט LocalModel ומציינים את הנתיב לקובץ המודל:

   Kotlin

   val localModel = LocalModel.Builder()
           .setAssetFilePath("model.tflite")
           // or .setAbsoluteFilePath(absolute path to model file)
           // or .setUri(URI to model file)
           .build()

   Java

   LocalModel localModel =
       new LocalModel.Builder()
           .setAssetFilePath("model.tflite")
           // or .setAbsoluteFilePath(absolute path to model file)
           // or .setUri(URI to model file)
           .build();

   הערה: אפליקציות שמטרגטות ל-Android 11 (רמת API 30) לא יכולות יותר לגשת לקבצים מאחסון חיצוני בגלל עדכוני אחסון ב-Android 11.
   הערה: אם יש לכם מודל שאומן באמצעות AutoML Vision Edge ב-Firebase (לא ב-Google Cloud), יכול להיות שההוראות שלמעלה לא יפעלו. הוראות מפורטות זמינות במדריך להעברת נתונים.

הגדרת מקור מודל שמתארח מרחוק

כדי להשתמש במודל שמתארח מרחוק, צריך להוריד את קובץ המודל לאחסון המקומי של המכשיר באמצעות הלוגיקה של האפליקציה, ואז לטעון אותו כמודל מקומי. מומלץ להשתמש ב-Cloud Storage for Firebase כדי לארח מודל. פרטים על ההטמעה מופיעים במדריך להעברת נתונים מ-Firebase ML ל-Cloud Storage.

הגדרת הכלי לתווית תמונות

אחרי שמגדירים את מקורות המודלים, יוצרים אובייקט ImageLabeler מאחד מהם.

אלה האפשרויות הזמינות:

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

אם יש לכם רק מודל שצורף באופן מקומי, פשוט יוצרים תווית מהאובייקט LocalModel:

Kotlin

val customImageLabelerOptions = CustomImageLabelerOptions.Builder(localModel)
    .setConfidenceThreshold(0.5f)
    .setMaxResultCount(5)
    .build()
val labeler = ImageLabeling.getClient(customImageLabelerOptions)

Java

CustomImageLabelerOptions customImageLabelerOptions =
        new CustomImageLabelerOptions.Builder(localModel)
            .setConfidenceThreshold(0.5f)
            .setMaxResultCount(5)
            .build();
ImageLabeler labeler = ImageLabeling.getClient(customImageLabelerOptions);

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

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

Kotlin

val modelFile = File(context.cacheDir, "my_downloaded_model.tflite")
val model = if (modelFile.exists()) {
    // Use the downloaded model if available
    LocalModel.Builder().setAbsoluteFilePath(modelFile.absolutePath).build()
} else {
    // Fall back to the bundled model
    LocalModel.Builder().setAssetFilePath("model.tflite").build()
}
val options = CustomImageLabelerOptions.Builder(model)
    .setConfidenceThreshold(0.5f)
    .setMaxResultCount(5)
    .build()
val labeler = ImageLabeling.getClient(options)

Java

File modelFile = new File(context.getCacheDir(), "my_downloaded_model.tflite");
LocalModel model;
if (modelFile.exists()) {
    // Use the downloaded model if available
    model = new LocalModel.Builder().setAbsoluteFilePath(modelFile.getAbsolutePath()).build();
} else {
    // Fall back to the bundled model
    model = new LocalModel.Builder().setAssetFilePath("model.tflite").build();
}
CustomImageLabelerOptions options = new CustomImageLabelerOptions.Builder(model)
    .setConfidenceThreshold(0.5f)
    .setMaxResultCount(5)
    .build();
ImageLabeler labeler = ImageLabeling.getClient(options);

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

Kotlin

val localFile = File(context.cacheDir, "my_remote_model.tflite")
if (localFile.exists()) {
    initializeLabeler(localFile)
} else {
    showLoadingUI()
    val storage = Firebase.storage
    val modelRef = storage.getReferenceFromUrl("gs://YOUR_BUCKET/path/to/model.tflite")
    modelRef.getFile(localFile)
        .addOnSuccessListener {
            hideLoadingUI()
            initializeLabeler(localFile)
        }
        .addOnFailureListener {
            showErrorUI()
        }
}

private fun initializeLabeler(modelFile: File) {
    val localModel = LocalModel.Builder().setAbsoluteFilePath(modelFile.absolutePath).build()
    val options = CustomImageLabelerOptions.Builder(localModel).build()
    val labeler = ImageLabeling.getClient(options)
    enableMLFeatures(labeler)
}

Java

File localFile = new File(context.getCacheDir(), "my_remote_model.tflite");
if (localFile.exists()) {
    initializeLabeler(localFile);
} else {
    showLoadingUI();
    FirebaseStorage storage = FirebaseStorage.getInstance();
    StorageReference modelRef = storage.getReferenceFromUrl("gs://YOUR_BUCKET/path/to/model.tflite");
    modelRef.getFile(localFile)
        .addOnSuccessListener(new OnSuccessListener<FileDownloadTask.TaskSnapshot>() {
            @Override
            public void onSuccess(FileDownloadTask.TaskSnapshot taskSnapshot) {
                hideLoadingUI();
                initializeLabeler(localFile);
            }
        })
        .addOnFailureListener(new OnFailureListener() {
            @Override
            public void onFailure(@NonNull Exception exception) {
                showErrorUI();
            }
        });
}

private void initializeLabeler(File modelFile) {
    LocalModel localModel = new LocalModel.Builder().setAbsoluteFilePath(modelFile.getAbsolutePath()).build();
    CustomImageLabelerOptions options = new CustomImageLabelerOptions.Builder(localModel).build();
    ImageLabeler labeler = ImageLabeling.getClient(options);
    enableMLFeatures(labeler);
}

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

לאחר מכן, לכל תמונה שרוצים לתייג, יוצרים InputImage אובייקט מהתמונה. התוויתן של התמונות פועל הכי מהר כשמשתמשים ב-Bitmap או, אם משתמשים ב-camera2 API, ב-YUV_420_888 media.Image, שהם הפורמטים המומלצים כשזה אפשרי.

אפשר ליצור אובייקט 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(). זה שימושי כשמשתמשים ב-ACTION_GET_CONTENT intent כדי להציג למשתמש בקשה לבחור תמונה מאפליקציית הגלריה שלו.

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. הפעלת הכלי להוספת תוויות לתמונות

כדי להוסיף תוויות לאובייקטים בתמונה, מעבירים את image האובייקט לשיטה process() של ImageLabeler.

Kotlin

labeler.process(image)
        .addOnSuccessListener { labels ->
            // Task completed successfully
            // ...
        }
        .addOnFailureListener { e ->
            // Task failed with an exception
            // ...
        }
ImageLabelingActivity.kt

Java

labeler.process(image)
        .addOnSuccessListener(new OnSuccessListener<List<ImageLabel>>() {
            @Override
            public void onSuccess(List<ImageLabel> labels) {
                // Task completed successfully
                // ...
            }
        })
        .addOnFailureListener(new OnFailureListener() {
            @Override
            public void onFailure(@NonNull Exception e) {
                // Task failed with an exception
                // ...
            }
        });
ImageLabelingActivity.java

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

4. קבלת מידע על ישויות שסומנו בתווית

אם פעולת התיוג של התמונה מצליחה, רשימה של אובייקטים מסוג ImageLabel מועברת למאזין ההצלחה. כל אובייקט ImageLabel מייצג משהו שקיבל תווית בתמונה. אפשר לקבל את תיאור הטקסט של כל תווית (אם הוא זמין במטא-נתונים של קובץ מודל LiteRT), את ציון רמת הביטחון ואת האינדקס. לדוגמה:

Kotlin

for (label in labels) {
    val text = label.text
    val confidence = label.confidence
    val index = label.index
}
ImageLabelingActivity.kt

Java

for (ImageLabel label : labels) {
    String text = label.getText();
    float confidence = label.getConfidence();
    int index = label.getIndex();
}
ImageLabelingActivity.java

הערה: אם משתמשים במודל LiteRT שלא תואם ל-ML Kit, תקבלו MlKitException עם קוד השגיאה MlKitException#INVALID_ARGUMENT וכמה פרטים על הסיבה לכך שהוא לא תואם. פרטים נוספים מפורטים במאמר דרישות התאימות של מודלים בהתאמה אישית.

טיפים לשיפור הביצועים בזמן אמת

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

• אם משתמשים ב-API‏ Camera או ב-API‏ 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.