หน้านี้ได้รับการแปลโดย Cloud Translation API

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

คุณใช้ ML Kit เพื่อตรวจจับและติดตามออบเจ็กต์ในเฟรมวิดีโอได้

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

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

เพิ่ม Firebase ลงในโปรเจ็กต์ Android หากยังไม่ได้เพิ่ม

เพิ่มทรัพยากร Dependency สำหรับคลัง Android ของ ML Kit ลงในไฟล์ 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ก่อน จากนั้นระบุการตั้งค่าตัวตรวจจับที่คุณต้องการเปลี่ยนจากค่าเริ่มต้น (ไม่บังคับ)

กำหนดค่าเครื่องตรวจจับออบเจ็กต์สำหรับ 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` จะจัดประเภทออบเจ็กต์ที่ตรวจพบเป็นหมวดหมู่คร่าวๆ หรือไม่ เมื่อเปิดใช้แล้ว เครื่องตรวจจับออบเจ็กต์จะจัดประเภทออบเจ็กต์เป็นหมวดหมู่ต่อไปนี้ สินค้าแฟชั่น อาหาร ของใช้ในบ้าน สถานที่ พืช และไม่ทราบ

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 สำหรับกรณีการใช้งานเหล่านี้

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()

รับอินสแตนซ์ของ 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อินสแตนซ์

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

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

ส่งรูปภาพไปยังเมธอด 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
            // ...
        }

หากการเรียกใช้ processImage() สำเร็จ ระบบจะส่งรายการ FirebaseVisionObject ไปยังเครื่องมือฟังที่สำเร็จ

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 ก่อน จากนั้นจึงแสดงรูปภาพ และซ้อนทับในขั้นตอนเดียว การทำเช่นนี้จะทำให้คุณแสดงผลไปยังพื้นผิวการแสดงผล เพียงครั้งเดียวสำหรับแต่ละเฟรมอินพุต
หากใช้ API ของ Camera2 ให้ถ่ายภาพในรูปแบบ ImageFormat.YUV_420_888

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