ตรวจจับและติดตามวัตถุด้วย ML Kit บน Android

หน้านี้อธิบาย Object Detection and Tracking APIเวอร์ชันเก่า ซึ่งเป็นส่วนหนึ่งของ ML Kit สำหรับ Firebase การพัฒนา API นี้ได้ย้ายไปที่ ML Kit SDK แบบสแตนด์อโลนแล้ว ซึ่งคุณสามารถใช้โดยมีหรือไม่มี Firebase ก็ได้ เรียนรู้เพิ่มเติม .

ดู Detect and track objects with ML Kit on Android สำหรับเอกสารล่าสุด

คุณสามารถใช้ ML Kit เพื่อตรวจจับและติดตามวัตถุข้ามเฟรมของวิดีโอได้

เมื่อคุณส่งภาพ ML Kit ML Kit จะส่งกลับรายการวัตถุที่ตรวจพบสูงสุดห้ารายการและตำแหน่งในรูปภาพสำหรับแต่ละภาพ เมื่อตรวจจับวัตถุในสตรีมวิดีโอ วัตถุทุกชิ้นจะมี ID ที่คุณสามารถใช้เพื่อติดตามวัตถุในรูปภาพต่างๆ คุณยังสามารถเลือกเปิดใช้งานการจัดประเภทอ็อบเจ็กต์หยาบ ซึ่งจะติดป้ายอ็อบเจ็กต์ด้วยคำอธิบายหมวดหมู่แบบกว้างๆ

ก่อนที่คุณจะเริ่ม

1. หากคุณยังไม่ได้ เพิ่ม Firebase ในโครงการ Android ของคุณ
2. เพิ่มการพึ่งพาสำหรับไลบรารี ML Kit Android ให้กับไฟล์ Gradle ของโมดูล (ระดับแอป) (โดยปกติคือ app/build.gradle ):

   apply plugin: 'com.android.application'
   apply plugin: 'com.google.gms.google-services'
   
   dependencies {
     // ...
   
     implementation 'com.google.firebase:firebase-ml-vision:24.0.3'
     implementation 'com.google.firebase:firebase-ml-vision-object-detection-model:19.0.6'
   }
   

1. กำหนดค่าเครื่องตรวจจับวัตถุ

หากต้องการเริ่มการตรวจจับและติดตามวัตถุ ขั้นแรกให้สร้างอินสแตนซ์ของ FirebaseVisionObjectDetector โดยระบุการตั้งค่าตัวตรวจจับที่คุณต้องการเปลี่ยนจากค่าเริ่มต้นหรือไม่ก็ได้

1. กำหนดค่าตัวตรวจจับวัตถุสำหรับกรณีการใช้งานของคุณด้วยออบเจ็กต์ FirebaseVisionObjectDetectorOptions คุณสามารถเปลี่ยนการตั้งค่าต่อไปนี้:

   การตั้งค่าตัวตรวจจับวัตถุ
   โหมดการตรวจจับ	STREAM_MODE (ค่าเริ่มต้น) | SINGLE_IMAGE_MODE ใน STREAM_MODE (ค่าเริ่มต้น) ตัวตรวจจับวัตถุจะทำงานโดยมีเวลาแฝงต่ำ แต่อาจให้ผลลัพธ์ที่ไม่สมบูรณ์ (เช่น กรอบขอบเขตหรือป้ายกำกับหมวดหมู่ที่ไม่ระบุ) ในการเรียกใช้ตัวตรวจจับสองสามครั้งแรก นอกจากนี้ ใน STREAM_MODE ตัวตรวจจับจะกำหนดรหัสติดตามให้กับออบเจ็กต์ ซึ่งคุณสามารถใช้ติดตามออบเจ็กต์ข้ามเฟรมได้ ใช้โหมดนี้เมื่อคุณต้องการติดตามวัตถุ หรือเมื่อเวลาแฝงต่ำเป็นสิ่งสำคัญ เช่น เมื่อประมวลผลสตรีมวิดีโอแบบเรียลไทม์ ใน SINGLE_IMAGE_MODE ตัวตรวจจับวัตถุจะรอจนกว่ากล่องขอบเขตของวัตถุที่ตรวจพบและป้ายกำกับหมวดหมู่ (หากคุณเปิดใช้งานการจัดหมวดหมู่) จะพร้อมใช้งานก่อนที่จะส่งคืนผลลัพธ์ ด้วยเหตุนี้ เวลาแฝงในการตรวจจับจึงอาจสูงขึ้น นอกจากนี้ ใน SINGLE_IMAGE_MODE จะไม่มีการกำหนดรหัสการติดตาม ใช้โหมดนี้หากเวลาแฝงไม่สำคัญและคุณไม่ต้องการจัดการกับผลลัพธ์บางส่วน
   ตรวจจับและติดตามวัตถุหลายชิ้น	false (ค่าเริ่มต้น) | true ไม่ว่าจะตรวจจับและติดตามวัตถุสูงสุดห้าชิ้นหรือเฉพาะวัตถุที่โดดเด่นที่สุด (ค่าเริ่มต้น)
   จำแนกวัตถุ	false (ค่าเริ่มต้น) | true ไม่ว่าจะจำแนกวัตถุที่ตรวจพบเป็นประเภทหยาบหรือไม่ เมื่อเปิดใช้งาน ตัวตรวจจับวัตถุจะจัดประเภทวัตถุเป็นหมวดหมู่ต่อไปนี้: สินค้าแฟชั่น อาหาร ของใช้ในบ้าน สถานที่ ต้นไม้ และที่ไม่รู้จัก

   API การตรวจจับและติดตามออบเจ็กต์ได้รับการปรับให้เหมาะสมสำหรับกรณีการใช้งานหลักสองกรณีนี้:

   • การตรวจจับและการติดตามวัตถุที่โดดเด่นที่สุดในช่องมองภาพของกล้องแบบเรียลไทม์
   • การตรวจจับวัตถุหลายชิ้นจากภาพนิ่ง

   หากต้องการกำหนดค่า API สำหรับกรณีการใช้งานเหล่านี้:

   Java

   // Live detection and tracking
   FirebaseVisionObjectDetectorOptions options =
           new FirebaseVisionObjectDetectorOptions.Builder()
                   .setDetectorMode(FirebaseVisionObjectDetectorOptions.STREAM_MODE)
                   .enableClassification()  // Optional
                   .build();
   
   // Multiple object detection in static images
   FirebaseVisionObjectDetectorOptions options =
           new FirebaseVisionObjectDetectorOptions.Builder()
                   .setDetectorMode(FirebaseVisionObjectDetectorOptions.SINGLE_IMAGE_MODE)
                   .enableMultipleObjects()
                   .enableClassification()  // Optional
                   .build();
   

   Kotlin+KTX

   // Live detection and tracking
   val options = FirebaseVisionObjectDetectorOptions.Builder()
           .setDetectorMode(FirebaseVisionObjectDetectorOptions.STREAM_MODE)
           .enableClassification()  // Optional
           .build()
   
   // Multiple object detection in static images
   val options = FirebaseVisionObjectDetectorOptions.Builder()
           .setDetectorMode(FirebaseVisionObjectDetectorOptions.SINGLE_IMAGE_MODE)
           .enableMultipleObjects()
           .enableClassification()  // Optional
           .build()
   

2. รับอินสแตนซ์ของ FirebaseVisionObjectDetector :

   Java

   FirebaseVisionObjectDetector objectDetector =
           FirebaseVision.getInstance().getOnDeviceObjectDetector();
   
   // Or, to change the default settings:
   FirebaseVisionObjectDetector objectDetector =
           FirebaseVision.getInstance().getOnDeviceObjectDetector(options);
   

   Kotlin+KTX

   val objectDetector = FirebaseVision.getInstance().getOnDeviceObjectDetector()
   
   // Or, to change the default settings:
   val objectDetector = FirebaseVision.getInstance().getOnDeviceObjectDetector(options)
   

   หมายเหตุ: ตรวจสอบคอนโซลเพื่อหาข้อผิดพลาดที่สร้างโดยตัวสร้าง

2. เรียกใช้เครื่องตรวจจับวัตถุ

หากต้องการตรวจจับและติดตามออบเจ็กต์ ให้ส่งรูปภาพไปยังเมธอด processImage() ของอินสแตนซ์ FirebaseVisionObjectDetector

สำหรับแต่ละเฟรมของวิดีโอหรือรูปภาพตามลำดับ ให้ทำดังต่อไปนี้:

1. สร้างวัตถุ FirebaseVisionImage จากรูปภาพของคุณ

   • หากต้องการสร้างออบเจ็กต์ FirebaseVisionImage จากออบเจ็ media.Image เช่น เมื่อถ่ายภาพจากกล้องของอุปกรณ์ ให้ส่งอ media.Image และการหมุนของรูปภาพไปที่ FirebaseVisionImage.fromMediaImage()

     หากคุณใช้ไลบรารี CameraX คลาส OnImageCapturedListener และ ImageAnalysis.Analyzer จะคำนวณค่าการหมุนให้กับคุณ ดังนั้น คุณเพียงแค่ต้องแปลงการหมุนให้เป็นค่าคงที่ ROTATION_ ของ ML Kit ก่อนที่จะเรียกใช้ FirebaseVisionImage.fromMediaImage() :

     Java

     private class YourAnalyzer implements ImageAnalysis.Analyzer {
     
         private int degreesToFirebaseRotation(int degrees) {
             switch (degrees) {
                 case 0:
                     return FirebaseVisionImageMetadata.ROTATION_0;
                 case 90:
                     return FirebaseVisionImageMetadata.ROTATION_90;
                 case 180:
                     return FirebaseVisionImageMetadata.ROTATION_180;
                 case 270:
                     return FirebaseVisionImageMetadata.ROTATION_270;
                 default:
                     throw new IllegalArgumentException(
                             "Rotation must be 0, 90, 180, or 270.");
             }
         }
     
         @Override
         public void analyze(ImageProxy imageProxy, int degrees) {
             if (imageProxy == null || imageProxy.getImage() == null) {
                 return;
             }
             Image mediaImage = imageProxy.getImage();
             int rotation = degreesToFirebaseRotation(degrees);
             FirebaseVisionImage image =
                     FirebaseVisionImage.fromMediaImage(mediaImage, rotation);
             // Pass image to an ML Kit Vision API
             // ...
         }
     }
     

     Kotlin+KTX

     private class YourImageAnalyzer : ImageAnalysis.Analyzer {
         private fun degreesToFirebaseRotation(degrees: Int): Int = when(degrees) {
             0 -> FirebaseVisionImageMetadata.ROTATION_0
             90 -> FirebaseVisionImageMetadata.ROTATION_90
             180 -> FirebaseVisionImageMetadata.ROTATION_180
             270 -> FirebaseVisionImageMetadata.ROTATION_270
             else -> throw Exception("Rotation must be 0, 90, 180, or 270.")
         }
     
         override fun analyze(imageProxy: ImageProxy?, degrees: Int) {
             val mediaImage = imageProxy?.image
             val imageRotation = degreesToFirebaseRotation(degrees)
             if (mediaImage != null) {
                 val image = FirebaseVisionImage.fromMediaImage(mediaImage, imageRotation)
                 // Pass image to an ML Kit Vision API
                 // ...
             }
         }
     }
     

     หากคุณไม่ได้ใช้ไลบรารีกล้องที่ให้การหมุนภาพ คุณสามารถคำนวณได้จากการหมุนของอุปกรณ์และการวางแนวของเซ็นเซอร์กล้องในอุปกรณ์:

     Java

     private static final SparseIntArray ORIENTATIONS = new SparseIntArray();
     static {
         ORIENTATIONS.append(Surface.ROTATION_0, 90);
         ORIENTATIONS.append(Surface.ROTATION_90, 0);
         ORIENTATIONS.append(Surface.ROTATION_180, 270);
         ORIENTATIONS.append(Surface.ROTATION_270, 180);
     }
     
     /**
      * 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, Context context)
             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);
     
         // On most devices, the sensor orientation is 90 degrees, but for some
         // devices it is 270 degrees. For devices with a sensor orientation of
         // 270, rotate the image an additional 180 ((270 + 270) % 360) degrees.
         CameraManager cameraManager = (CameraManager) context.getSystemService(CAMERA_SERVICE);
         int sensorOrientation = cameraManager
                 .getCameraCharacteristics(cameraId)
                 .get(CameraCharacteristics.SENSOR_ORIENTATION);
         rotationCompensation = (rotationCompensation + sensorOrientation + 270) % 360;
     
         // Return the corresponding FirebaseVisionImageMetadata rotation value.
         int result;
         switch (rotationCompensation) {
             case 0:
                 result = FirebaseVisionImageMetadata.ROTATION_0;
                 break;
             case 90:
                 result = FirebaseVisionImageMetadata.ROTATION_90;
                 break;
             case 180:
                 result = FirebaseVisionImageMetadata.ROTATION_180;
                 break;
             case 270:
                 result = FirebaseVisionImageMetadata.ROTATION_270;
                 break;
             default:
                 result = FirebaseVisionImageMetadata.ROTATION_0;
                 Log.e(TAG, "Bad rotation value: " + rotationCompensation);
         }
         return result;
     }
     VisionImage.java

     Kotlin+KTX

     private val ORIENTATIONS = SparseIntArray()
     
     init {
         ORIENTATIONS.append(Surface.ROTATION_0, 90)
         ORIENTATIONS.append(Surface.ROTATION_90, 0)
         ORIENTATIONS.append(Surface.ROTATION_180, 270)
         ORIENTATIONS.append(Surface.ROTATION_270, 180)
     }
     /**
      * 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, context: Context): 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)
     
         // On most devices, the sensor orientation is 90 degrees, but for some
         // devices it is 270 degrees. For devices with a sensor orientation of
         // 270, rotate the image an additional 180 ((270 + 270) % 360) degrees.
         val cameraManager = context.getSystemService(CAMERA_SERVICE) as CameraManager
         val sensorOrientation = cameraManager
                 .getCameraCharacteristics(cameraId)
                 .get(CameraCharacteristics.SENSOR_ORIENTATION)!!
         rotationCompensation = (rotationCompensation + sensorOrientation + 270) % 360
     
         // Return the corresponding FirebaseVisionImageMetadata rotation value.
         val result: Int
         when (rotationCompensation) {
             0 -> result = FirebaseVisionImageMetadata.ROTATION_0
             90 -> result = FirebaseVisionImageMetadata.ROTATION_90
             180 -> result = FirebaseVisionImageMetadata.ROTATION_180
             270 -> result = FirebaseVisionImageMetadata.ROTATION_270
             else -> {
                 result = FirebaseVisionImageMetadata.ROTATION_0
                 Log.e(TAG, "Bad rotation value: $rotationCompensation")
             }
         }
         return result
     }
     VisionImage.kt

     จากนั้นส่งผ่านวัตถุ media.Image และค่าการหมุนไปที่ FirebaseVisionImage.fromMediaImage() :

     Java

     FirebaseVisionImage image = FirebaseVisionImage.fromMediaImage(mediaImage, rotation);
     VisionImage.java

     Kotlin+KTX

     val image = FirebaseVisionImage.fromMediaImage(mediaImage, rotation)
     VisionImage.kt

   • หากต้องการสร้างออบเจ็กต์ FirebaseVisionImage จากไฟล์ URI ให้ส่งบริบทของแอปและ URI ไฟล์ไปที่ FirebaseVisionImage.fromFilePath() สิ่งนี้มีประโยชน์เมื่อคุณใช้เจตนา ACTION_GET_CONTENT เพื่อแจ้งให้ผู้ใช้เลือกรูปภาพจากแอปแกลเลอรีของตน

     Java

     FirebaseVisionImage image;
     try {
         image = FirebaseVisionImage.fromFilePath(context, uri);
     } catch (IOException e) {
         e.printStackTrace();
     }
     VisionImage.java

     Kotlin+KTX

     val image: FirebaseVisionImage
     try {
         image = FirebaseVisionImage.fromFilePath(context, uri)
     } catch (e: IOException) {
         e.printStackTrace()
     }
     VisionImage.kt

   • หากต้องการสร้างออบเจ็กต์ FirebaseVisionImage จาก ByteBuffer หรืออาร์เรย์ไบต์ ขั้นแรกให้คำนวณการหมุนรูปภาพตามที่อธิบายไว้ข้างต้นสำหรับอินพุต media.Image

     จากนั้น สร้างออบเจ็กต์ FirebaseVisionImageMetadata ที่มีความสูง ความกว้าง รูปแบบการเข้ารหัสสี และการหมุนของรูปภาพ ดังนี้

     Java

     FirebaseVisionImageMetadata metadata = new FirebaseVisionImageMetadata.Builder()
             .setWidth(480)   // 480x360 is typically sufficient for
             .setHeight(360)  // image recognition
             .setFormat(FirebaseVisionImageMetadata.IMAGE_FORMAT_NV21)
             .setRotation(rotation)
             .build();
     VisionImage.java

     Kotlin+KTX

     val metadata = FirebaseVisionImageMetadata.Builder()
             .setWidth(480) // 480x360 is typically sufficient for
             .setHeight(360) // image recognition
             .setFormat(FirebaseVisionImageMetadata.IMAGE_FORMAT_NV21)
             .setRotation(rotation)
             .build()
     VisionImage.kt

     ใช้บัฟเฟอร์หรืออาร์เรย์ และวัตถุข้อมูลเมตา เพื่อสร้างวัตถุ FirebaseVisionImage :

     Java

     FirebaseVisionImage image = FirebaseVisionImage.fromByteBuffer(buffer, metadata);
     // Or: FirebaseVisionImage image = FirebaseVisionImage.fromByteArray(byteArray, metadata);
     VisionImage.java

     Kotlin+KTX

     val image = FirebaseVisionImage.fromByteBuffer(buffer, metadata)
     // Or: val image = FirebaseVisionImage.fromByteArray(byteArray, metadata)
     VisionImage.kt

   • หากต้องการสร้างวัตถุ FirebaseVisionImage จากวัตถุ Bitmap :

     Java

     FirebaseVisionImage image = FirebaseVisionImage.fromBitmap(bitmap);
     VisionImage.java

     Kotlin+KTX

     val image = FirebaseVisionImage.fromBitmap(bitmap)
     VisionImage.kt

     รูปภาพที่แสดงโดยวัตถุ Bitmap จะต้องตั้งตรง โดยไม่ต้องหมุนเพิ่มเติม

2. ส่งภาพไปยัง processImage() วิธีการ:

   Java

   objectDetector.processImage(image)
           .addOnSuccessListener(
                   new OnSuccessListener<List<FirebaseVisionObject>>() {
                       @Override
                       public void onSuccess(List<FirebaseVisionObject> detectedObjects) {
                           // Task completed successfully
                           // ...
                       }
                   })
           .addOnFailureListener(
                   new OnFailureListener() {
                       @Override
                       public void onFailure(@NonNull Exception e) {
                           // Task failed with an exception
                           // ...
                       }
                   });
   

   Kotlin+KTX

   objectDetector.processImage(image)
           .addOnSuccessListener { detectedObjects ->
               // Task completed successfully
               // ...
           }
           .addOnFailureListener { e ->
               // Task failed with an exception
               // ...
           }
   

   หมายเหตุ: ตรวจสอบคอนโซลเพื่อดูข้อผิดพลาดที่เกิดจากตัวตรวจจับ

3. หากการเรียกไปยัง processImage() สำเร็จ รายการของ FirebaseVisionObject จะถูกส่งไปยัง Listener ที่สำเร็จ

   หมายเหตุ: ในโหมดสตรีมมิ่ง ตัวตรวจจับวัตถุอาจต้องประมวลผล 30 เฟรมขึ้นไป ขึ้นอยู่กับประสิทธิภาพของอุปกรณ์ ก่อนที่จะตรวจพบวัตถุแรก

   FirebaseVisionObject แต่ละรายการมีคุณสมบัติดังต่อไปนี้:

   กล่องปิดล้อม	Rect แสดงตำแหน่งของวัตถุในภาพ
   รหัสติดตาม	จำนวนเต็มที่ระบุวัตถุระหว่างรูปภาพ ค่าว่างใน SINGLE_IMAGE_MODE
   หมวดหมู่	หมวดหมู่หยาบของวัตถุ หากตัวตรวจจับวัตถุไม่ได้เปิดใช้งานการจัดหมวดหมู่ นี่จะเป็น FirebaseVisionObject.CATEGORY_UNKNOWN เสมอ
   ความมั่นใจ	ค่าความเชื่อมั่นของการจำแนกวัตถุ หากตัวตรวจจับวัตถุไม่ได้เปิดใช้งานการจัดหมวดหมู่ หรือวัตถุถูกจัดประเภทเป็นไม่ทราบ ค่านี้จะถือเป็น null

   Java

   // The list of detected objects contains one item if multiple object detection wasn't enabled.
   for (FirebaseVisionObject obj : detectedObjects) {
       Integer id = obj.getTrackingId();
       Rect bounds = obj.getBoundingBox();
   
       // If classification was enabled:
       int category = obj.getClassificationCategory();
       Float confidence = obj.getClassificationConfidence();
   }
   

   Kotlin+KTX

   // The list of detected objects contains one item if multiple object detection wasn't enabled.
   for (obj in detectedObjects) {
       val id = obj.trackingId       // A number that identifies the object across images
       val bounds = obj.boundingBox  // The object's position in the image
   
       // If classification was enabled:
       val category = obj.classificationCategory
       val confidence = obj.classificationConfidence
   }
   

ปรับปรุงการใช้งานและประสิทธิภาพ

เพื่อประสบการณ์ผู้ใช้ที่ดีที่สุด โปรดปฏิบัติตามหลักเกณฑ์เหล่านี้ในแอปของคุณ:

• การตรวจหาวัตถุที่ประสบความสำเร็จขึ้นอยู่กับความซับซ้อนในการมองเห็นของวัตถุ วัตถุที่มีคุณสมบัติด้านการมองเห็นเพียงเล็กน้อยอาจต้องใช้พื้นที่ขนาดใหญ่กว่าของภาพจึงจะตรวจพบได้ คุณควรให้คำแนะนำแก่ผู้ใช้ในการจับอินพุตที่ทำงานได้ดีกับประเภทของวัตถุที่คุณต้องการตรวจจับ
• เมื่อใช้การจัดหมวดหมู่ หากคุณต้องการตรวจจับอ็อบเจ็กต์ที่ไม่อยู่ในหมวดหมู่ที่รองรับ ให้ใช้การจัดการพิเศษสำหรับอ็อบเจ็กต์ที่ไม่รู้จัก

นอกจากนี้ โปรดตรวจสอบ [แอปแสดงการออกแบบวัสดุของ ML Kit][showcase-link]{: .external } และ รูปแบบการออกแบบวัสดุสำหรับคอลเล็กชันฟีเจอร์ที่ขับเคลื่อนด้วยแมชชีนเลิร์นนิง

เมื่อใช้โหมดสตรีมมิ่งในแอปพลิเคชันแบบเรียลไทม์ ให้ปฏิบัติตามคำแนะนำเหล่านี้เพื่อให้ได้เฟรมเรตที่ดีที่สุด:

• อย่าใช้การตรวจจับวัตถุหลายรายการในโหมดสตรีมมิ่ง เนื่องจากอุปกรณ์ส่วนใหญ่ไม่สามารถสร้างเฟรมเรตที่เพียงพอได้

• ปิดการใช้งานการจัดหมวดหมู่หากคุณไม่ต้องการมัน

• คันเร่งเรียกไปที่เครื่องตรวจจับ หากมีเฟรมวิดีโอใหม่ในขณะที่ตัวตรวจจับกำลังทำงานอยู่ ให้ปล่อยเฟรมนั้น
• หากคุณใช้เอาต์พุตของตัวตรวจจับเพื่อวางซ้อนกราฟิกบนรูปภาพอินพุต อันดับแรกรับผลลัพธ์จาก ML Kit จากนั้นเรนเดอร์รูปภาพและโอเวอร์เลย์ในขั้นตอนเดียว การทำเช่นนี้ คุณจะเรนเดอร์ไปยังพื้นผิวจอแสดงผลเพียงครั้งเดียวสำหรับแต่ละเฟรมอินพุต

• หากคุณใช้ Camera2 API ให้จับภาพในรูปแบบ ImageFormat.YUV_420_888

  หากคุณใช้ Camera API รุ่นเก่า ให้จับภาพในรูปแบบ ImageFormat.NV21