ตรวจจับและติดตามวัตถุด้วย 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 จะแสดงรายการวัตถุที่ตรวจพบสูงสุด 5 รายการและตำแหน่งของวัตถุเหล่านั้นในรูปภาพสำหรับรูปภาพแต่ละรูป เมื่อตรวจหาวัตถุในสตรีมวิดีโอ วัตถุทุกรายการจะมีรหัสที่คุณสามารถใช้ติดตามวัตถุในรูปภาพต่างๆ ได้ นอกจากนี้ คุณยังเปิดใช้การแยกประเภทออบเจ็กต์แบบหยาบได้ (ไม่บังคับ) ซึ่งจะติดป้ายกำกับออบเจ็กต์ด้วยคำอธิบายหมวดหมู่แบบกว้าง

ก่อนเริ่มต้น

1. เพิ่ม Firebase ลงในโปรเจ็กต์ Android หากยังไม่ได้ดำเนินการ
2. เพิ่มทรัพยากร Dependency สำหรับคลัง 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. กำหนดค่าตัวตรวจจับวัตถุสำหรับ Use Case ของคุณด้วยออบเจ็กต์ FirebaseVisionObjectDetectorOptions คุณสามารถเปลี่ยนการตั้งค่าต่อไปนี้ได้

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

   API การตรวจจับและติดตามวัตถุได้รับการเพิ่มประสิทธิภาพเพื่อการใช้งานหลัก 2 กรณีต่อไปนี้

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

   วิธีกำหนดค่า API สำหรับ Use Case เหล่านี้

   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

   // 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

   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

     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

     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

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

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

     Java

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

     Kotlin

     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

     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

     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

     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

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

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

3. หากการเรียก processImage() สําเร็จ ระบบจะส่งรายการ FirebaseVisionObject ไปยัง Listener ของความสําเร็จ

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

   FirebaseVisionObject แต่ละรายการมีพร็อพเพอร์ตี้ต่อไปนี้

   กรอบล้อมรอบ	Rect ที่ระบุตำแหน่งของวัตถุในรูปภาพ
   รหัสติดตาม	จำนวนเต็มที่ระบุวัตถุในรูปภาพ Null ใน 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

   // 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
   }
   

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

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

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

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

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

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

• ปิดใช้การจัดประเภทหากไม่จำเป็น

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

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

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