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

פילוח תמונות מואץ בזמן אמת ב-Android באמצעות LiteRT

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

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

ב-codelab הזה נסביר איך ליצור אפליקציית Android שמבצעת פילוח תמונות בזמן אמת בפיד מצלמה פעיל באמצעות זמן הריצה החדש של Google ל-TensorFlow Lite‏, LiteRT. תקבלו אפליקציית Android ראשונית ותוסיפו לה יכולות של פילוח תמונות. בנוסף, נסביר על שלבי העיבוד המקדים, ההסקה והעיבוד שלאחר ההסקה. תצטרכו:

ליצור אפליקציית Android שמפלח תמונות בזמן אמת.
שילוב של מודל LiteRT שעבר אימון מראש לחלוקת תמונות למקטעים.
מעבדים מראש את תמונת הקלט בשביל המודל.
משתמשים בסביבת זמן הריצה LiteRT להאצת המעבד (CPU) והמעבד הגרפי (GPU).
הסבר על עיבוד הפלט של המודל כדי להציג את מסכת הפילוח.
איך משנים את ההגדרה של המצלמה הקדמית.

בסופו של דבר, תיצרו משהו דומה לתמונה הבאה:

אפליקציה שהשימוש בה הסתיים

דרישות מוקדמות

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

פיתוח ל-Android באמצעות Kotlin ו-Android Studio
מושגים בסיסיים בעיבוד תמונה

מה תלמדו

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

הדרישות

גרסה עדכנית של Android Studio (נבדקה בגרסה v2025.1.1).
מכשיר Android פיזי. מומלץ לבדוק את התכונה במכשירי Galaxy ו-Pixel.
קוד לדוגמה (מ-GitHub).
ידע בסיסי בפיתוח ל-Android ב-Kotlin.

2. חלוקת תמונות למקטעים

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

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

דוגמה לפילוח

‫LiteRT: דחיפה של הקצה של למידת מכונה במכשיר

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

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

3. להגדרה

שכפול המאגר

קודם כל, משכפלים את המאגר של LiteRT:

git clone https://github.com/google-ai-edge/litert-samples.git

litert-samples/v2/image_segmentation היא הספרייה עם כל המשאבים שתצטרכו. ב-Codelab הזה תצטרכו רק את פרויקט kotlin_cpu_gpu/android_starter. אם נתקעתם, כדאי לעיין בפרויקט המוגמר: kotlin_cpu_gpu/android

הערה לגבי נתיבי קבצים

במדריך הזה, נתיבי הקבצים מצוינים בפורמט של Linux/macOS. אם אתם משתמשים ב-Windows, תצטרכו לשנות את הנתיבים בהתאם.

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

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

נתחיל בייבוא אפליקציית המתחילים אל Android Studio.

פותחים את Android Studio ובוחרים באפשרות Open (פתיחה).

פתיחה של Android Studio

מנווטים לספרייה kotlin_cpu_gpu/android_starter ופותחים אותה.

Android Starter

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

בסרגל הכלים של Android Studio, לוחצים על Sync Project with Gradle Files (סנכרון הפרויקט עם קובצי Gradle).

סנכרון תפריטים

חשוב לא לדלג על השלב הזה – אם הוא לא יעבוד, לא תהיה משמעות לשאר המדריך.

הפעלת אפליקציית המתחילים

אחרי שמייבאים את הפרויקט ל-Android Studio, אפשר להריץ את האפליקציה בפעם הראשונה.

מחברים את מכשיר Android למחשב באמצעות USB ולוחצים על Run (הפעלה) בסרגל הכלים של Android Studio.

כפתור ההפעלה

האפליקציה אמורה להיפתח במכשיר. יוצג לכם פיד חי מהמצלמה, אבל עדיין לא תתבצע פילוח. כל העריכות שתבצעו בקבצים במדריך הזה יהיו בספרייה litert-samples/v2/image_segmentation/kotlin_cpu_gpu/android_starter/app/src/main/java/com/google/ai/edge/examples/image_segmentation (עכשיו אתם יודעים למה Android Studio משנה את המבנה שלה 😃).

Project Dir

תראו גם TODO תגובות בקבצים ImageSegmentationHelper.kt, MainViewModel.kt ו-view/SegmentationOverlay.kt. בשלבים הבאים תטמיעו את הפונקציונליות של פילוח תמונות על ידי מילוי ה-TODO האלה.

4. הסבר על אפליקציית המתחילים

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

‫app/src/main/java/com/google/ai/edge/examples/image_segmentation/MainActivity.kt: זו נקודת הכניסה הראשית של האפליקציה. הוא מגדיר את ממשק המשתמש באמצעות Jetpack Compose ומטפל בהרשאות הגישה למצלמה.
‫app/src/main/java/com/google/ai/edge/examples/image_segmentation/MainViewModel.kt: ה-ViewModel הזה מנהל את מצב ממשק המשתמש ומתאם את תהליך פילוח התמונה.
‫app/src/main/java/com/google/ai/edge/examples/image_segmentation/ImageSegmentationHelper.kt: כאן נוסיף את הלוגיקה המרכזית של פילוח התמונה. הוא יטען את המודל, יעבד את הפריימים של המצלמה ויריץ את ההסקה.
‫app/src/main/java/com/google/ai/edge/examples/image_segmentation/view/CameraScreen.kt: פונקציית Composable שמציגה את התצוגה המקדימה של המצלמה ואת שכבת העל של חלוקת הגוף.
‫app/download_model.gradle: הסקריפט הזה מוריד את selfie_multiclass.tflite. זהו מודל TensorFlow Lite שעבר אימון מראש לפילוח תמונות, ובו נשתמש.

5. הסבר על LiteRT והוספת יחסי תלות

עכשיו נוסיף לאפליקציית המתחילים את הפונקציונליות של פילוח התמונה.

1. מוסיפים את התלות ב-LiteRT

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

פותחים את הקובץ app/build.gradle.kts ומוסיפים את השורה הבאה לבלוק dependencies:

// LiteRT for on-device ML
implementation(libs.litert)

אחרי שמוסיפים את התלות, מסנכרנים את הפרויקט עם קובצי Gradle על ידי לחיצה על הלחצן Sync Now (סנכרון עכשיו) שמופיע בפינה השמאלית העליונה של Android Studio.

סנכרן עכשיו

2. הסבר על ממשקי API מרכזיים של LiteRT

פתיחה `ImageSegmentationHelper.kt`

לפני שכותבים את קוד ההטמעה, חשוב להבין את רכיבי הליבה של LiteRT API שבהם תשתמשו. מוודאים שמייבאים מחבילת com.google.ai.edge.litert, ומוסיפים את הייבוא הבא לחלק העליון של ImageSegmentationHelper.kt:

import com.google.ai.edge.litert.Accelerator
import com.google.ai.edge.litert.CompiledModel

‫CompiledModel: זוהי המחלקה המרכזית לאינטראקציה עם מודל TFLite. הוא מייצג מודל שעבר קומפילציה מראש ואופטימיזציה למאיץ חומרה ספציפי (כמו CPU או GPU). הקומפילציה המוקדמת הזו היא תכונה מרכזית של LiteRT שמובילה להסקת מסקנות מהירה ויעילה יותר.
‫CompiledModel.Options: משתמשים במחלקה הזו של Builder כדי להגדיר את CompiledModel. ההגדרה הכי חשובה היא ציון מאיץ החומרה שרוצים להשתמש בו להרצת המודל.
‫Accelerator: סוג ה-enum הזה מאפשר לכם לבחור את החומרה להסקת מסקנות. פרויקט המתחילים כבר מוגדר לטיפול באפשרויות האלה:
- ‫Accelerator.CPU: להרצת המודל ב-CPU של המכשיר. זו האפשרות הכי תואמת לכל המכשירים.
- ‫Accelerator.GPU: להרצת המודל ב-GPU של המכשיר. לרוב, התהליך הזה מהיר משמעותית יותר מאשר במעבד (CPU) בדגמים מבוססי-תמונות.
מאגרי קלט ופלט (TensorBuffer): LiteRT משתמש ב-TensorBuffer לקלט ולפלט של המודל. כך אתם מקבלים שליטה מדויקת בזיכרון ונמנעים מהעתקות מיותרות של נתונים. תקבלו את המאגרים האלה ישירות ממופע CompiledModel באמצעות model.createInputBuffers() ו-model.createOutputBuffers(), ואז תכתבו את נתוני הקלט במאגרים ותקראו את התוצאות מהם.
‫model.run(): זו הפונקציה שמבצעת את ההסקה. מעבירים אליו את מאגרי הקלט והפלט, ו-LiteRT מטפל במשימה המורכבת של הפעלת המודל במאיץ החומרה שנבחר.

6. סיום ההטמעה הראשונית של ImageSegmentationHelper

עכשיו הגיע הזמן לכתוב קוד. תשלימו את ההטמעה הראשונית של ImageSegmentationHelper.kt. התהליך כולל הגדרה של Segmenter מחלקה פרטית להחזקת מודל LiteRT והטמעה של הפונקציה cleanup() כדי לשחרר אותו בצורה נכונה.

משלימים את המחלקה Segmenter ואת הפונקציה cleanup(): בקובץ ImageSegmentationHelper.kt מופיע שלד של מחלקה פרטית בשם Segmenter ופונקציה בשם cleanup(). קודם כול, משלימים את המחלקה Segmenter על ידי הגדרת בנאי שיכיל את המודל, יצירת מאפיינים למאגרי הקלט והפלט והוספה של שיטת close() לשחרור המודל. לאחר מכן, מטמיעים את הפונקציה cleanup() כדי להפעיל את השיטה החדשה close().מחליפים את המחלקה הקיימת Segmenter ואת הפונקציה cleanup() בקוד הבא: (~line 83)
```
private class Segmenter(
    // Add this argument
    private val model: CompiledModel,
    private val coloredLabels: List<ColoredLabel>,
) {
    // Add these private vals
    private val inputBuffers = model.createInputBuffers()
    private val outputBuffers = model.createOutputBuffers()

    fun cleanup() {
      // cleanup buffers
      inputBuffers.forEach { it.close() }
      outputBuffers.forEach { it.close() }
      // cleanup model
      model.close()
    }
}
```
הגדרת השיטה toAccelerator: השיטה הזו ממפה את ה-enums של קיצורי הדרך שהוגדרו בתפריט קיצורי הדרך ל-enums של קיצורי הדרך שספציפיים למודולים המיובאים של LiteRT (בערך שורה 225):
```
fun toAccelerator(acceleratorEnum: AcceleratorEnum): Accelerator {
  return when (acceleratorEnum) {
    AcceleratorEnum.CPU -> Accelerator.CPU
    AcceleratorEnum.GPU -> Accelerator.GPU
  }
}
```

מאחלים את CompiledModel: עכשיו מוצאים את הפונקציה initSegmenter. כאן תיצרו את מופע CompiledModel ותשתמשו בו כדי ליצור מופע של מחלקת Segmenter שהוגדרה עכשיו. הקוד הזה מגדיר את המודל עם המאיץ שצוין (CPU או GPU) ומכין אותו להסקת מסקנות. מחליפים את TODO ב-initSegmenter בהטמעה הבאה (Cmd/Ctrl+f ‏'initSegmenter` או שורה 62 בערך):

cleanup()
try {
  withContext(singleThreadDispatcher) {
    val model =
      CompiledModel.create(
        context.assets,
        "selfie_multiclass.tflite",
        CompiledModel.Options(toAccelerator(acceleratorEnum)),
        null,
      )
    segmenter = Segmenter(model, coloredLabels)
    Log.d(TAG, "Created an image segmenter")
  }
} catch (e: Exception) {
  Log.i(TAG, "Create LiteRT from selfie_multiclass is failed: ${e.message}")
  _error.emit(e)
}

7. התחלת הפילוח והעיבוד המקדים

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

פילוח לפי טריגר

תהליך הפילוח מתחיל ב-MainViewModel.kt, שמקבל מסגרות מהמצלמה.

פתיחה `MainViewModel.kt`

הפעלת חלוקת הגוף מתוך פריימים של המצלמה: הפונקציות segment ב-MainViewModel הן נקודת הכניסה למשימת חלוקת הגוף שלנו. הפונקציות האלה מופעלות בכל פעם שתמונה חדשה זמינה מהמצלמה או נבחרת מהגלריה. הפונקציות האלה מפעילות את השיטה segment ב-ImageSegmentationHelper. מחליפים את TODO בשתי הפונקציות segment בטקסט הבא (שורה 107 בערך):

// For ImageProxy (from CameraX)
fun segment(imageProxy: ImageProxy) {
    segmentJob =
        viewModelScope.launch {
            imageSegmentationHelper.segment(imageProxy.toBitmap(), imageProxy.imageInfo.rotationDegrees)
            imageProxy.close()
        }
}

// For Bitmaps (from gallery)
fun segment(bitmap: Bitmap, rotationDegrees: Int) {
    segmentJob =
        viewModelScope.launch {
            val argbBitmap = bitmap.copy(Bitmap.Config.ARGB_8888, true)
            imageSegmentationHelper.segment(argbBitmap, rotationDegrees)
        }
}

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

עכשיו נחזור אל ImageSegmentationHelper.kt כדי לטפל בעיבוד התמונה מראש.

פתיחה `ImageSegmentationHelper.kt`

הטמעה של פונקציית Public segment: הפונקציה הזו משמשת כ-wrapper שקורא לפונקציית segment הפרטית בתוך המחלקה Segmenter. מחליפים את TODO ב- (~line 95):

try {
  withContext(singleThreadDispatcher) {
    segmenter?.segment(bitmap, rotationDegrees)?.let { if (isActive) _segmentation.emit(it) }
  }
} catch (e: Exception) {
  Log.i(TAG, "Image segment error occurred: ${e.message}")
  _error.emit(e)
}

הטמעה של עיבוד מקדים: הפונקציה הפרטית segment בתוך המחלקה Segmenter היא המקום שבו נבצע את השינויים הנדרשים בתמונת הקלט כדי להכין אותה למודל. הפעולות האלה כוללות שינוי גודל, סיבוב ונרמול של התמונה. הפונקציה הזו תקרא לפונקציה פרטית אחרת segment כדי לבצע את ההסקה. מחליפים את TODO בפונקציה segment(bitmap: Bitmap, ...) בערך הבא (~שורה 121):

val totalStartTime = SystemClock.uptimeMillis()
val rotation = -rotationDegrees / 90
val (h, w) = Pair(256, 256)

// Preprocessing
val preprocessStartTime = SystemClock.uptimeMillis()
var image = bitmap.scale(w, h, true)
image = rot90Clockwise(image, rotation)
val inputFloatArray = normalize(image, 127.5f, 127.5f)
Log.d(TAG, "Preprocessing time: ${SystemClock.uptimeMillis() - preprocessStartTime} ms")

// Inference
val inferenceStartTime = SystemClock.uptimeMillis()
val segmentResult = segment(inputFloatArray)
Log.d(TAG, "Inference time: ${SystemClock.uptimeMillis() - inferenceStartTime} ms")

Log.d(TAG, "Total segmentation time: ${SystemClock.uptimeMillis() - totalStartTime} ms")
return SegmentationResult(segmentResult, SystemClock.uptimeMillis() - inferenceStartTime)

8. הסקת מסקנות ראשונית באמצעות LiteRT

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

פתיחה `ImageSegmentationHelper.kt`

הטמעת הפעלת המודל: הפונקציה הפרטית segment(inputFloatArray: FloatArray) היא המקום שבו מתבצעת אינטראקציה ישירה עם השיטה run() של LiteRT. אנחנו כותבים את הנתונים שעברו עיבוד מראש למאגר הקלט, מריצים את המודל וקוראים את התוצאות ממאגר הפלט. מחליפים את TODO בפונקציה הזו (בערך בשורה 188):

val (h, w, c) = Triple(256, 256, 6)

// MODEL EXECUTION PHASE
val modelExecStartTime = SystemClock.uptimeMillis()

// Write input data - measure time
val bufferWriteStartTime = SystemClock.uptimeMillis()
inputBuffers[0].writeFloat(inputFloatArray)
val bufferWriteTime = SystemClock.uptimeMillis() - bufferWriteStartTime
Log.d(TAG, "Buffer write time: $bufferWriteTime ms")

// Optional tensor inspection
logTensorStats("Input tensor", inputFloatArray)

// Run model inference - measure time
val modelRunStartTime = SystemClock.uptimeMillis()
model.run(inputBuffers, outputBuffers)
val modelRunTime = SystemClock.uptimeMillis() - modelRunStartTime
Log.d(TAG, "Model.run() time: $modelRunTime ms")

// Read output data - measure time
val bufferReadStartTime = SystemClock.uptimeMillis()
val outputFloatArray = outputBuffers[0].readFloat()
val outputBuffer = FloatBuffer.wrap(outputFloatArray)
val bufferReadTime = SystemClock.uptimeMillis() - bufferReadStartTime
Log.d(TAG, "Buffer read time: $bufferReadTime ms")

val modelExecTime = SystemClock.uptimeMillis() - modelExecStartTime
Log.d(TAG, "Total model execution time: $modelExecTime ms")

// Optional tensor inspection
logTensorStats("Output tensor", outputFloatArray)

// POSTPROCESSING PHASE
val postprocessStartTime = SystemClock.uptimeMillis()

// Process mask from model output
val inferenceData = InferenceData(width = w, height = h, channels = c, buffer = outputBuffer)
val mask = processImage(inferenceData)

val postprocessTime = SystemClock.uptimeMillis() - postprocessStartTime
Log.d(TAG, "Postprocessing time (mask creation): $postprocessTime ms")

return Segmentation(
  listOf(Mask(mask, inferenceData.width, inferenceData.height)),
  coloredLabels,
)

9. עיבוד תמונה (Post Processing) והצגת שכבת-העל

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

פתיחה `ImageSegmentationHelper.kt`

הטמעה של עיבוד הפלט: הפונקציה processImage ממירה את פלט הנקודה הצפה הגולמי מהמודל ל-ByteBuffer שמייצג את מסכת הפילוח. הוא עושה את זה על ידי מציאת המחלקה עם ההסתברות הכי גבוהה לכל פיקסל. מחליפים את TODO שלו ב- (~line 238):

val mask = ByteBuffer.allocateDirect(inferenceData.width * inferenceData.height)
for (i in 0 until inferenceData.height) {
    for (j in 0 until inferenceData.width) {
        val offset = inferenceData.channels * (i * inferenceData.width + j)

        var maxIndex = 0
        var maxValue = inferenceData.buffer.get(offset)

        for (index in 1 until inferenceData.channels) {
            if (inferenceData.buffer.get(offset + index) > maxValue) {
                maxValue = inferenceData.buffer.get(offset + index)
                maxIndex = index
            }
        }
        mask.put(i * inferenceData.width + j, maxIndex.toByte())
    }
}
return mask

פתיחה `MainViewModel.kt`

איסוף ועיבוד של תוצאות הפילוח: עכשיו חוזרים אל MainViewModel כדי לעבד את תוצאות הפילוח מ-ImageSegmentationHelper. ה-segmentationUiShareFlow אוסף את SegmentationResult, ממיר את המסכה לBitmap צבעוני ומספק אותה לממשק המשתמש. מחליפים את TODO בנכס segmentationUiShareFlow ב-‎ (~line 63) – לא מחליפים את הקוד שכבר נמצא שם, רק ממלאים את הגוף:

viewModelScope.launch {
  imageSegmentationHelper.segmentation
    .filter { it.segmentation.masks.isNotEmpty() }
    .map {
      val segmentation = it.segmentation
      val mask = segmentation.masks[0]
      val maskArray = mask.data
      val width = mask.width
      val height = mask.height
      val pixelSize = width * height
      val pixels = IntArray(pixelSize)

      val colorLabels =
        segmentation.coloredLabels.mapIndexed { index, coloredLabel ->
          ColorLabel(index, coloredLabel.label, coloredLabel.argb)
        }
      // Set color for pixels
      for (i in 0 until pixelSize) {
        val colorLabel = colorLabels[maskArray[i].toInt()]
        val color = colorLabel.getColor()
        pixels[i] = color
      }
      // Get image info
      val overlayInfo = OverlayInfo(pixels = pixels, width = width, height = height)

      val inferenceTime = it.inferenceTime
      Pair(overlayInfo, inferenceTime)
    }
    .collect { flow.emit(it) }
}

פתיחה `view/SegmentationOverlay.kt`

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

‫Handle Overlay Orientation: מאתרים את TODO בקובץ SegmentationOverlay.kt ומחליפים אותו בקוד הבא. הקוד הזה בודק אם המצלמה הקדמית פעילה, ואם כן, הוא הופך את שכבת העל Bitmap אופקית לפני שהיא מצוירת על Canvas. ‫(~line 42):
```
val orientedBitmap =
  if (lensFacing == CameraSelector.LENS_FACING_FRONT) {
    // Create a matrix for horizontal flipping
    val matrix = Matrix().apply { preScale(-1f, 1f) }
    Bitmap.createBitmap(image, 0, 0, image.width, image.height, matrix, false).also {
      image.recycle()
    }
  } else {
    image
  }
```

10. הרצה ושימוש באפליקציה הסופית

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

הפעלת האפליקציה: מחברים את מכשיר Android ולוחצים על Run (הפעלה) בסרגל הכלים של Android Studio.

כפתור ההפעלה

בדיקת התכונות: אחרי שהאפליקציה תופעל, אמור להופיע פיד חי מהמצלמה עם שכבת-על צבעונית של פילוח.
- החלפת מצלמות: מקישים על סמל החלפת המצלמה בחלק העליון כדי לעבור בין המצלמה הקדמית למצלמה האחורית. שימו לב איך שכבת העל מסתובבת בצורה נכונה.
- שינוי המאיץ: מקישים על הלחצן 'CPU' או 'GPU' בחלק התחתון כדי להחליף את מאיץ החומרה. בודקים את השינוי בזמן ההסקה שמוצג בתחתית המסך. ה-GPU צריך להיות מהיר משמעותית.
- שימוש בתמונה מהגלריה: מקישים על הכרטיסייה 'גלריה' בחלק העליון כדי לבחור תמונה מגלריית התמונות במכשיר. האפליקציה תריץ פילוח על התמונה הסטטית שנבחרה.

ממשק משתמש אחר

עכשיו יש לכם אפליקציה פונקציונלית לחלוטין לפילוח תמונות בזמן אמת, שמבוססת על LiteRT!

11. מתקדם (אופציונלי): שימוש ב-NPU

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

כדי לנסות את הגרסה של ה-NPU, פותחים את הפרויקט kotlin_npu/android ב-Android Studio. הקוד דומה מאוד לגרסת ה-CPU/GPU, והוא מוגדר להשתמש בנציג NPU.

כדי להשתמש בנציג NPU, צריך להירשם לתוכנית הגישה המוקדמת.

12. מעולה!

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

משלבים את זמן הריצה של LiteRT באפליקציה ל-Android.
טעינה והרצה של מודל פילוח תמונות של TFLite.
מעבדים מראש את הקלט של המודל.
מעבדים את הפלט של המודל כדי ליצור מסכת פילוח.
אפשר להשתמש ב-CameraX כדי ליצור אפליקציית מצלמה בזמן אמת.

השלבים הבאים

נסו מודל אחר של פילוח תמונות.
מתנסים עם נציגים שונים של LiteRT (CPU, ‏ GPU, ‏ NPU).

מידע נוסף

מסמכי תיעוד של LiteRT

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

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

דרישות מוקדמות

מה תלמדו

הדרישות

2. חלוקת תמונות למקטעים

‫LiteRT: דחיפה של הקצה של למידת מכונה במכשיר

3. להגדרה

שכפול המאגר

הערה לגבי נתיבי קבצים

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

הפעלת אפליקציית המתחילים

4. הסבר על אפליקציית המתחילים

5. הסבר על LiteRT והוספת יחסי תלות

1. מוסיפים את התלות ב-LiteRT

2. הסבר על ממשקי API מרכזיים של LiteRT

פתיחה ImageSegmentationHelper.kt

6. סיום ההטמעה הראשונית של ImageSegmentationHelper

7. התחלת הפילוח והעיבוד המקדים

פילוח לפי טריגר

פתיחה MainViewModel.kt

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

פתיחה ImageSegmentationHelper.kt

8. הסקת מסקנות ראשונית באמצעות LiteRT

פתיחה ImageSegmentationHelper.kt

9. עיבוד תמונה (Post Processing) והצגת שכבת-העל

פתיחה ImageSegmentationHelper.kt

פתיחה MainViewModel.kt

פתיחה view/SegmentationOverlay.kt

10. הרצה ושימוש באפליקציה הסופית

11. מתקדם (אופציונלי): שימוש ב-NPU

12. מעולה!

השלבים הבאים

מידע נוסף

פילוח תמונות מואץ בזמן אמת ב-Android באמצעות LiteRT

פתיחה `ImageSegmentationHelper.kt`

פתיחה `MainViewModel.kt`

פתיחה `ImageSegmentationHelper.kt`

פתיחה `ImageSegmentationHelper.kt`

פתיחה `ImageSegmentationHelper.kt`

פתיחה `MainViewModel.kt`

פתיחה `view/SegmentationOverlay.kt`