כשמעבירים תמונה ל-ML Kit, הוא מזהה עד חמישה אובייקטים בתמונה יחד עם המיקום של כל אובייקט בתמונה. כשמזהים אובייקטים בסטרימינג של וידאו, לכל אובייקט יש מזהה ייחודי שבעזרתו אפשר לעקוב אחרי האובייקט.
אפשר להשתמש במודל מותאם אישית לסיווג תמונות כדי לסווג את האובייקטים שמזוהים. במאמר מודלים בהתאמה אישית באמצעות ML Kit תוכלו למצוא הנחיות לגבי דרישות התאימות למודלים, איפה אפשר למצוא מודלים שעברו אימון מקדים ואיך לאמן מודלים משלכם.
יש שתי דרכים לשלב מודל מותאם אישית. אפשר לארוז את המודל על ידי הוספתו לתיקיית הנכסים של האפליקציה, או להוריד אותו באופן דינמי מ-Firebase. הטבלה הבאה משווה בין שתי האפשרויות.
מודל בחבילה | מודל מתארח |
---|---|
המודל הוא חלק מ-APK של האפליקציה, ולכן הוא גדל. | המודל אינו חלק מה-APK שלך. כדי לארח את המשחק, אתם צריכים להעלות אותו ל-Firebase Machine Learning. |
הדגם זמין באופן מיידי, גם כשמכשיר Android במצב אופליין | המערכת מורידה את המודל על פי דרישה |
אין צורך בפרויקט Firebase | נדרש פרויקט Firebase |
כדי לעדכן את המודל, צריך לפרסם מחדש את האפליקציה | דחיפת עדכוני מודל מבלי לפרסם מחדש את האפליקציה |
אין בדיקות A/B מובנות | בדיקות A/B פשוטות עם הגדרת תצורה מרחוק ב-Firebase |
אני רוצה לנסות
- אפשר לעיין באפליקציית Vision למתחילים כדי לראות שימוש לדוגמה במודל הכלול, ובאפליקציה למתחילים של Automl כדי לראות דוגמה לשימוש במודל המתארח.
- אפשר לעיין באפליקציית התצוגה לדוגמה של עיצוב חדשני תלת-ממדי כדי לראות את ההטמעה מקצה לקצה של ה-API הזה.
לפני שמתחילים
בקובץ
build.gradle
ברמת הפרויקט, חשוב לכלול את מאגר Maven של Google בקטעbuildscript
וגם בקטעallprojects
.מוסיפים את יחסי התלות של ספריות ML Kit ל-Android לקובץ הדירוג ברמת האפליקציה של המודול, שהוא בדרך כלל
app/build.gradle
:כדי לקבץ מודל עם האפליקציה:
dependencies { // ... // Object detection & tracking feature with custom bundled model implementation 'com.google.mlkit:object-detection-custom:17.0.1' }
כדי להוריד באופן דינמי מודל מ-Firebase, צריך להוסיף את התלות
linkFirebase
:dependencies { // ... // Object detection & tracking feature with model downloaded // from firebase implementation 'com.google.mlkit:object-detection-custom:17.0.1' implementation 'com.google.mlkit:linkfirebase:17.0.0' }
אם אתם רוצים להוריד מודל, הקפידו להוסיף את Firebase לפרויקט Android שלכם, אם עדיין לא עשיתם זאת. אין צורך לעשות זאת כשמקבצים את המודל.
1. טעינת המודל
הגדרת מקור של מודל מקומי
כדי לקבץ את המודל עם האפליקציה שלך:
מעתיקים את קובץ המודל (בדרך כלל מסתיים ב-
.tflite
או.lite
) לתיקייהassets/
של האפליקציה. (יכול להיות שקודם תצטרכו ליצור את התיקייה על ידי לחיצה ימנית על התיקייהapp/
, ולאחר מכן לחיצה על New > Folder > Assets Folder).לאחר מכן, צריך להוסיף את הקוד הבא לקובץ
build.gradle
של האפליקציה כדי לוודא ש-Gradle לא תדחס את קובץ המודל כשמפתחים את האפליקציה:android { // ... aaptOptions { noCompress "tflite" // or noCompress "lite" } }
קובץ המודל ייכלל בחבילת האפליקציה ויהיה זמין ל-ML Kit כנכס גולמי.
יוצרים אובייקט
LocalModel
, ומציינים את הנתיב לקובץ המודל:Kotlin
val localModel = LocalModel.Builder() .setAssetFilePath("model.tflite") // or .setAbsoluteFilePath(absolute file path to model file) // or .setUri(URI to model file) .build()
Java
LocalModel localModel = new LocalModel.Builder() .setAssetFilePath("model.tflite") // or .setAbsoluteFilePath(absolute file path to model file) // or .setUri(URI to model file) .build();
הגדרת מקור מודל שמתארח ב-Firebase
כדי להשתמש במודל באירוח מרחוק, צריך ליצור אובייקט CustomRemoteModel
על ידי FirebaseModelSource
, ולציין את השם שהקציתם למודל כשפרסמתם אותו:
Kotlin
// Specify the name you assigned in the Firebase console. val remoteModel = CustomRemoteModel .Builder(FirebaseModelSource.Builder("your_model_name").build()) .build()
Java
// Specify the name you assigned in the Firebase console. CustomRemoteModel remoteModel = new CustomRemoteModel .Builder(new FirebaseModelSource.Builder("your_model_name").build()) .build();
לאחר מכן, מתחילים את המשימה של הורדת המודל, ומציינים את התנאים שבהם רוצים לאפשר הורדה. אם המודל לא נמצא במכשיר, או אם יש גרסה חדשה יותר של המודל, המשימה תוריד את המודל באופן אסינכרוני מ-Firebase:
Kotlin
val downloadConditions = DownloadConditions.Builder() .requireWifi() .build() RemoteModelManager.getInstance().download(remoteModel, downloadConditions) .addOnSuccessListener { // Success. }
Java
DownloadConditions downloadConditions = new DownloadConditions.Builder() .requireWifi() .build(); RemoteModelManager.getInstance().download(remoteModel, downloadConditions) .addOnSuccessListener(new OnSuccessListener() { @Override public void onSuccess(@NonNull Task task) { // Success. } });
אפליקציות רבות מתחילות את משימת ההורדה בקוד האתחול שלהן, אבל תוכלו לעשות זאת בכל שלב לפני שתצטרכו להשתמש במודל.
2. הגדרה של מזהה אובייקטים
אחרי שמגדירים את מקורות המודל, צריך להגדיר את גלאי האובייקטים
לתרחיש לדוגמה באמצעות אובייקט CustomObjectDetectorOptions
. תוכלו לשנות את ההגדרות הבאות:
הגדרות של מזהה אובייקטים | |
---|---|
מצב זיהוי |
STREAM_MODE (ברירת מחדל) | SINGLE_IMAGE_MODE
במצב בשיטה |
זיהוי אובייקטים מרובים ומעקב אחריהם |
false (ברירת מחדל) | true
האם לזהות ולעקוב אחרי עד חמישה אובייקטים או רק את האובייקט הבולט ביותר (ברירת מחדל). |
סיווג אובייקטים |
false (ברירת מחדל) | true
האם לסווג אובייקטים שזוהו באמצעות
מודל המסווג המותאם אישית שסופק. כדי להשתמש במודל הסיווג בהתאמה אישית, צריך להגדיר את הערך הזה כ- |
סף ביטחון בסיווג |
ציון מהימנות מינימלי של תוויות שזוהו. אם המדיניות לא מוגדרת, המערכת תשתמש בכל סף סיווג שצוין במטא-נתונים של המודל. אם המודל לא מכיל מטא-נתונים או אם המטא-נתונים לא מציינים סף מסווג, ייעשה שימוש בסף ברירת מחדל של 0.0. |
מספר מקסימלי של תוויות לאובייקט |
מספר התוויות המקסימלי לכל אובייקט שהמזהה יחזיר. אם המדיניות לא מוגדרת, המערכת תשתמש בערך ברירת המחדל 10. |
ה-API לזיהוי אובייקטים ולמעקב מותאם לשני תרחישי השימוש העיקריים הבאים:
- זיהוי ומעקב בזמן אמת של האובייקט הבולט ביותר בעינית המצלמה.
- זיהוי של מספר אובייקטים מתמונה סטטית.
כדי להגדיר את ה-API לתרחישים לדוגמה הבאים, באמצעות מודל בחבילה מקומית:
Kotlin
// Live detection and tracking val customObjectDetectorOptions = CustomObjectDetectorOptions.Builder(localModel) .setDetectorMode(CustomObjectDetectorOptions.STREAM_MODE) .enableClassification() .setClassificationConfidenceThreshold(0.5f) .setMaxPerObjectLabelCount(3) .build() // Multiple object detection in static images val customObjectDetectorOptions = CustomObjectDetectorOptions.Builder(localModel) .setDetectorMode(CustomObjectDetectorOptions.SINGLE_IMAGE_MODE) .enableMultipleObjects() .enableClassification() .setClassificationConfidenceThreshold(0.5f) .setMaxPerObjectLabelCount(3) .build() val objectDetector = ObjectDetection.getClient(customObjectDetectorOptions)
Java
// Live detection and tracking CustomObjectDetectorOptions customObjectDetectorOptions = new CustomObjectDetectorOptions.Builder(localModel) .setDetectorMode(CustomObjectDetectorOptions.STREAM_MODE) .enableClassification() .setClassificationConfidenceThreshold(0.5f) .setMaxPerObjectLabelCount(3) .build(); // Multiple object detection in static images CustomObjectDetectorOptions customObjectDetectorOptions = new CustomObjectDetectorOptions.Builder(localModel) .setDetectorMode(CustomObjectDetectorOptions.SINGLE_IMAGE_MODE) .enableMultipleObjects() .enableClassification() .setClassificationConfidenceThreshold(0.5f) .setMaxPerObjectLabelCount(3) .build(); ObjectDetector objectDetector = ObjectDetection.getClient(customObjectDetectorOptions);
אם יש לכם מודל באירוח מרוחק, תצטרכו לבדוק שהוא הורד לפני שמריצים אותו. אפשר לבדוק את הסטטוס של משימת הורדת המודל באמצעות ה-method isModelDownloaded()
של מנהל המודלים.
צריך לוודא זאת רק לפני שמריצים את המזהה, אבל אם יש לכם גם מודל באירוח מרחוק וגם מודל בחבילה מקומית, כדאי לבצע את הבדיקה הזו כשיוצרים יצירת יצירה של מזהה התמונות: אם הוא הורד מהמודל המקומי, כדאי ליצור גלאי מהמודל המרוחק.
Kotlin
RemoteModelManager.getInstance().isModelDownloaded(remoteModel) .addOnSuccessListener { isDownloaded -> val optionsBuilder = if (isDownloaded) { CustomObjectDetectorOptions.Builder(remoteModel) } else { CustomObjectDetectorOptions.Builder(localModel) } val customObjectDetectorOptions = optionsBuilder .setDetectorMode(CustomObjectDetectorOptions.SINGLE_IMAGE_MODE) .enableClassification() .setClassificationConfidenceThreshold(0.5f) .setMaxPerObjectLabelCount(3) .build() val objectDetector = ObjectDetection.getClient(customObjectDetectorOptions) }
Java
RemoteModelManager.getInstance().isModelDownloaded(remoteModel) .addOnSuccessListener(new OnSuccessListener() { @Override public void onSuccess(Boolean isDownloaded) { CustomObjectDetectorOptions.Builder optionsBuilder; if (isDownloaded) { optionsBuilder = new CustomObjectDetectorOptions.Builder(remoteModel); } else { optionsBuilder = new CustomObjectDetectorOptions.Builder(localModel); } CustomObjectDetectorOptions customObjectDetectorOptions = optionsBuilder .setDetectorMode(CustomObjectDetectorOptions.SINGLE_IMAGE_MODE) .enableClassification() .setClassificationConfidenceThreshold(0.5f) .setMaxPerObjectLabelCount(3) .build(); ObjectDetector objectDetector = ObjectDetection.getClient(customObjectDetectorOptions); } });
אם יש לכם רק מודל שמתארח מרחוק, צריך להשבית את הפונקציונליות שקשורה למודל – למשל הצגת באפור או הסתרה של חלק מממשק המשתמש – עד שמוודאים שהמודל הורד. לשם כך, אפשר לצרף מאזין ל-method download()
של מנהל המודלים:
Kotlin
RemoteModelManager.getInstance().download(remoteModel, conditions) .addOnSuccessListener { // Download complete. Depending on your app, you could enable the ML // feature, or switch from the local model to the remote model, etc. }
Java
RemoteModelManager.getInstance().download(remoteModel, conditions) .addOnSuccessListener(new OnSuccessListener() { @Override public void onSuccess(Void v) { // Download complete. Depending on your app, you could enable // the ML feature, or switch from the local model to the remote // model, etc. } });
3. הכנת התמונה לקלט
יוצרים אובייקטInputImage
מהתמונה.
מזהה האובייקטים פועל ישירות מ-Bitmap
, מ-NV21 ByteBuffer
או מ-YUV_420_888 media.Image
. מומלץ ליצור InputImage
מהמקורות האלה אם יש לכם גישה ישירה לאחד מהם. אם תיצרו InputImage
ממקורות אחרים, אנחנו נטפל בהמרה באופן פנימי עבורכם, ויכול להיות שהיא תהיה פחות יעילה.
ניתן ליצור אובייקט 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 }
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)
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() }
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 ) // Or: val image = InputImage.fromByteArray( byteArray, /* image width */ 480, /* image height */ 360, rotationDegrees, InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12 )
Java
InputImage image = InputImage.fromByteBuffer(byteBuffer, /* image width */ 480, /* image height */ 360, rotationDegrees, InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12 ); // Or: InputImage image = InputImage.fromByteArray( byteArray, /* image width */480, /* image height */360, rotation, InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12 );
באמצעות Bitmap
כדי ליצור אובייקט InputImage
מאובייקט Bitmap
, צריך בהצהרה הבאה:
Kotlin
val image = InputImage.fromBitmap(bitmap, 0)
Java
InputImage image = InputImage.fromBitmap(bitmap, rotationDegree);
התמונה מיוצגת על ידי אובייקט Bitmap
יחד עם מעלות סיבוב.
4. הפעלת 'גלאי אובייקטים'
Kotlin
objectDetector .process(image) .addOnFailureListener(e -> {...}) .addOnSuccessListener(results -> { for (detectedObject in results) { // ... } });
Java
objectDetector .process(image) .addOnFailureListener(e -> {...}) .addOnSuccessListener(results -> { for (DetectedObject detectedObject : results) { // ... } });
5. קבלת מידע על אובייקטים מתויגים
אם הקריאה ל-process()
תסתיים בהצלחה, רשימת ה-DetectedObject
תועבר ל-event listener.
כל DetectedObject
מכיל את המאפיינים הבאים:
תיבת תיחום | Rect שמציין את מיקום האובייקט בתמונה. |
||||||
מזהה לצורכי מעקב | מספר שלם המזהה את האובייקט בתמונות שונות. ערך null ב-SINGLE_IMAGE_mode. | ||||||
Labels (תוויות) |
|
Kotlin
// The list of detected objects contains one item if multiple // object detection wasn't enabled. for (detectedObject in results) { val boundingBox = detectedObject.boundingBox val trackingId = detectedObject.trackingId for (label in detectedObject.labels) { val text = label.text val index = label.index val confidence = label.confidence } }
Java
// The list of detected objects contains one item if multiple // object detection wasn't enabled. for (DetectedObject detectedObject : results) { Rect boundingBox = detectedObject.getBoundingBox(); Integer trackingId = detectedObject.getTrackingId(); for (Label label : detectedObject.getLabels()) { String text = label.getText(); int index = label.getIndex(); float confidence = label.getConfidence(); } }
הבטחת חוויית משתמש מעולה
כדי ליהנות מחוויית המשתמש הטובה ביותר, יש לפעול לפי ההנחיות הבאות באפליקציה:
- זיהוי אובייקטים מוצלח תלוי במורכבות החזותית של האובייקט. כדי שיזוהו, יכול להיות שאובייקטים שיש להם מספר קטן של תכונות חזותיות יצטרכו לתפוס חלק גדול יותר מהתמונה. צריך להדריך את המשתמשים איך לתעד קלט שעובד היטב עם סוגי האובייקטים שרוצים לזהות.
- כשמשתמשים בסיווג, כדי לזהות אובייקטים שלא מתאימים בדיוק לקטגוריות הנתמכות, כדאי ליישם טיפול מיוחד באובייקטים לא ידועים.
בנוסף, עיינו באפליקציית התצוגה של ML Kit Material Design ובאוסף תבניות לתכונות שמבוססות על למידת מכונה ב-Material Design.
Improving performance
אם אתם רוצים להשתמש בזיהוי אובייקטים באפליקציה בזמן אמת, עליכם לפעול לפי ההנחיות הבאות כדי להגיע לקצבי הפריימים הטובים ביותר:כשאתם משתמשים במצב סטרימינג באפליקציה בזמן אמת, לא כדאי להשתמש בזיהוי אובייקטים מרובים, מכיוון שרוב המכשירים לא יכולים ליצור קצבי פריימים מתאימים.
- אם משתמשים ב-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
.