ตรวจหา ติดตาม และจัดประเภทออบเจ็กต์ด้วยโมเดลการแยกประเภทที่กำหนดเองใน Android

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

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

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

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

โมเดลที่รวมไว้ด้วยกัน โมเดลที่โฮสต์
โมเดลเป็นส่วนหนึ่งของ APK ของแอป ซึ่งจะเพิ่มขนาดของ APK โมเดลไม่ได้เป็นส่วนหนึ่งของ APK ระบบจะโฮสต์โมเดลโดยการอัปโหลดไปยัง Cloud Storage เราขอแนะนำให้ใช้ Cloud Storage สำหรับ Firebase
โมเดลพร้อมใช้งานทันที แม้ว่าอุปกรณ์ Android จะออฟไลน์อยู่ก็ตาม แอปของคุณต้องมีโค้ดเพื่อดาวน์โหลดโมเดลตามความต้องการ
ไม่จำเป็นต้องมีโปรเจ็กต์ Firebase ต้องมีโปรเจ็กต์ Firebase (หากใช้ Cloud Storage สำหรับ Firebase)
คุณต้องเผยแพร่แอปอีกครั้งเพื่ออัปเดตโมเดล ส่งการอัปเดตโมเดลโดยไม่ต้องเผยแพร่แอปอีกครั้ง
ไม่มีการทดสอบ A/B ในตัว การทดสอบ A/B ด้วย การกำหนดค่าระยะไกลของ Firebase

ลองเลย

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

1. ในไฟล์ build.gradle.kts ระดับโปรเจ็กต์ ให้ตรวจสอบว่าได้รวม ที่เก็บ Maven ของ Google ไว้ในส่วน buildscript และ allprojects แล้ว

  1. เพิ่มทรัพยากร Dependency สำหรับคลัง ML Kit สำหรับ Android ลงในไฟล์ Gradle ระดับแอปของโมดูล ซึ่งโดยปกติจะเป็นไฟล์ app/build.gradle.kts ดังนี้

    สำหรับการรวมโมเดลไว้กับแอป

    dependencies {
      // ...
      // Object detection & tracking feature with custom bundled model
      implementation("com.google.mlkit:object-detection-custom:17.0.2")
    }
    
  2. หากต้องการดาวน์โหลดโมเดลจาก Cloud Storage สำหรับ Firebase ให้ ตรวจสอบว่าคุณ ได้เพิ่ม Firebase ลงในโปรเจ็กต์ Android แล้ว หากยังไม่ได้เพิ่ม การดำเนินการนี้ไม่จำเป็นเมื่อคุณรวม โมเดลไว้ด้วยกัน

1. โหลดโมเดล

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

กำหนดค่าแหล่งที่มาของโมเดลในเครื่อง

วิธีรวมโมเดลไว้กับแอป

  1. คัดลอกไฟล์โมเดล (โดยปกติจะลงท้ายด้วย .tflite หรือ .lite) ไปยังโฟลเดอร์ assets/ ของแอป (คุณอาจต้องสร้างโฟลเดอร์ก่อนโดยคลิกขวาที่โฟลเดอร์ app/ แล้วคลิกใหม่ > โฟลเดอร์ > โฟลเดอร์เนื้อหา)

  2. สร้างออบเจ็กต์ LocalModel โดยระบุเส้นทางไปยังไฟล์โมเดล

    Kotlin

    val localModel = LocalModel.Builder()
            .setAssetFilePath("model.tflite")
            // or .setAbsoluteFilePath(absolute path to model file)
            // or .setUri(URI to model file)
            .build()

    Java

    LocalModel localModel =
        new LocalModel.Builder()
            .setAssetFilePath("model.tflite")
            // or .setAbsoluteFilePath(absolute path to model file)
            // or .setUri(URI to model file)
            .build();

กำหนดค่าแหล่งที่มาของโมเดลที่โฮสต์จากระยะไกล

หากต้องการใช้โมเดลที่โฮสต์จากระยะไกล คุณต้องดาวน์โหลดไฟล์โมเดลลงในพื้นที่เก็บข้อมูลในเครื่องของอุปกรณ์โดยใช้ตรรกะของแอปเอง แล้วโหลดเป็นโมเดลในเครื่อง เราขอแนะนำให้ใช้ Cloud Storage for Firebase เพื่อโฮสต์โมเดล ดูรายละเอียดการใช้งานได้ที่ คู่มือการย้ายข้อมูลจาก Firebase ML ไปยัง Cloud Storage

2. กำหนดค่าตัวตรวจจับวัตถุ

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

การตั้งค่าตัวตรวจจับวัตถุ
โหมดการตรวจจับ STREAM_MODE (ค่าเริ่มต้น) | SINGLE_IMAGE_MODE

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

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

ตรวจจับและติดตามวัตถุหลายรายการ false (ค่าเริ่มต้น) | true

เลือกว่าจะตรวจจับและติดตามวัตถุได้สูงสุด 5 รายการหรือเฉพาะวัตถุที่โดดเด่นที่สุด (ค่าเริ่มต้น)

แยกประเภทวัตถุ false (ค่าเริ่มต้น) | true

เลือกว่าจะแยกประเภทวัตถุที่ตรวจพบโดยใช้โมเดลตัวแยกประเภทแบบกำหนดเองที่ให้ไว้หรือไม่ หากต้องการใช้โมเดลการแยกประเภทที่กำหนดเอง คุณต้องตั้งค่านี้เป็น true

เกณฑ์ความเชื่อมั่นในการแยกประเภท

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

ป้ายกำกับสูงสุดต่อวัตถุ

จำนวนป้ายกำกับสูงสุดต่อวัตถุที่ตัวตรวจจับจะ แสดงผล หากไม่ได้ตั้งค่าไว้ ระบบจะใช้ค่าเริ่มต้นเป็น 10

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

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

วิธีกำหนดค่า 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);

หากมีโมเดลที่โฮสต์จากระยะไกล คุณจะต้องตรวจสอบว่าได้ดาวน์โหลดโมเดลแล้วก่อนที่จะดำเนินการ

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

Kotlin

val modelFile = File(context.cacheDir, "my_remote_model.tflite")

val model = if (modelFile.exists()) {
    // Use the downloaded model if available
    LocalModel.Builder().setAbsoluteFilePath(modelFile.absolutePath).build()
} else {
    // Fall back to the bundled model
    LocalModel.Builder().setAssetFilePath("model.tflite").build()
}

val customObjectDetectorOptions =
        CustomObjectDetectorOptions.Builder(model)
        .setDetectorMode(CustomObjectDetectorOptions.SINGLE_IMAGE_MODE)
        .enableClassification()
        .setClassificationConfidenceThreshold(0.5f)
        .setMaxPerObjectLabelCount(3)
        .build()

val objectDetector =
        ObjectDetection.getClient(customObjectDetectorOptions)

Java

File modelFile = new File(context.getCacheDir(), "my_remote_model.tflite");

LocalModel model;
if (modelFile.exists()) {
    // Use the downloaded model if available
    model = new LocalModel.Builder().setAbsoluteFilePath(modelFile.getAbsolutePath()).build();
} else {
    // Fall back to the bundled model
    model = new LocalModel.Builder().setAssetFilePath("model.tflite").build();
}

CustomObjectDetectorOptions customObjectDetectorOptions =
        new CustomObjectDetectorOptions.Builder(model)
                .setDetectorMode(CustomObjectDetectorOptions.SINGLE_IMAGE_MODE)
                .enableClassification()
                .setClassificationConfidenceThreshold(0.5f)
                .setMaxPerObjectLabelCount(3)
                .build();

ObjectDetector objectDetector =
        ObjectDetection.getClient(customObjectDetectorOptions);

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

Kotlin

val localFile = File(context.cacheDir, "my_remote_model.tflite")
if (localFile.exists()) {
    // Model is already cached, initialize immediately
    initializeDetector(localFile)
} else {
    // Model is not yet available, show loading UI and start download
    showLoadingUI()
    val storage = Firebase.storage
    val modelRef = storage.getReferenceFromUrl("gs://YOUR_BUCKET/path/to/model.tflite")
    modelRef.getFile(localFile)
        .addOnSuccessListener {
            // Download complete, initialize the detector
            hideLoadingUI()
            initializeDetector(localFile)
        }
        .addOnFailureListener {
            // Handle download error
            showErrorUI()
        }
}

private fun initializeDetector(modelFile: File) {
    val localModel = LocalModel.Builder().setAbsoluteFilePath(modelFile.absolutePath).build()
    val customObjectDetectorOptions = CustomObjectDetectorOptions.Builder(localModel)
            .setDetectorMode(CustomObjectDetectorOptions.SINGLE_IMAGE_MODE)
            .enableClassification()
            .build()
    val objectDetector = ObjectDetection.getClient(customObjectDetectorOptions)
    // Enable ML-related UI features here
    enableMLFeatures(objectDetector)
}

Java

File localFile = new File(context.getCacheDir(), "my_remote_model.tflite");
if (localFile.exists()) {
    // Model is already cached, initialize immediately
    initializeDetector(localFile);
} else {
    // Model is not yet available, show loading UI and start download
    showLoadingUI();
    FirebaseStorage storage = FirebaseStorage.getInstance();
    StorageReference modelRef = storage.getReferenceFromUrl("gs://YOUR_BUCKET/path/to/model.tflite");
    modelRef.getFile(localFile)
        .addOnSuccessListener(new OnSuccessListener<FileDownloadTask.TaskSnapshot>() {
            @Override
            public void onSuccess(FileDownloadTask.TaskSnapshot taskSnapshot) {
                // Download complete, initialize the detector
                hideLoadingUI();
                initializeDetector(localFile);
            }
        })
        .addOnFailureListener(new OnFailureListener() {
            @Override
            public void onFailure(@NonNull Exception exception) {
                // Handle download error
                showErrorUI();
            }
        });
}

private void initializeDetector(File modelFile) {
    LocalModel localModel = new LocalModel.Builder().setAbsoluteFilePath(modelFile.getAbsolutePath()).build();
    CustomObjectDetectorOptions customObjectDetectorOptions =
            new CustomObjectDetectorOptions.Builder(localModel)
                    .setDetectorMode(CustomObjectDetectorOptions.SINGLE_IMAGE_MODE)
                    .enableClassification()
                    .build();
    ObjectDetector objectDetector = ObjectDetection.getClient(customObjectDetectorOptions);
    // Enable ML-related UI features here
    enableMLFeatures(objectDetector);
}

3. เตรียมรูปภาพอินพุต

สร้างออบเจ็กต์ InputImage จากรูปภาพ ตัวตรวจจับวัตถุจะทำงานโดยตรงจาก Bitmap, NV21 ByteBuffer หรือ media.Image YUV_420_888 เราขอแนะนำให้สร้าง 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 ไปยัง Listener ที่สำเร็จ

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

กรอบล้อมรอบ Rect ที่ระบุตำแหน่งของวัตถุใน รูปภาพ
รหัสติดตาม จำนวนเต็มที่ระบุวัตถุในรูปภาพ เป็น Null ใน SINGLE_IMAGE_MODE
ป้ายกำกับ
คำอธิบายป้ายกำกับ คำอธิบายข้อความของป้ายกำกับ จะแสดงผลก็ต่อเมื่อข้อมูลเมตาของโมเดล LiteRT มีคำอธิบายป้ายกำกับ
ดัชนีป้ายกำกับ ดัชนีของป้ายกำกับในป้ายกำกับทั้งหมดที่ตัวแยกประเภท รองรับ
ความเชื่อมั่นของป้ายกำกับ ค่า Confidence ของการแยกประเภทวัตถุ

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 สำหรับฟีเจอร์ที่ขับเคลื่อนด้วยแมชชีนเลิร์นนิง

การปรับปรุงประสิทธิภาพการทำงาน

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

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

  • หากใช้ API ของ Camera หรือ camera2 ให้ควบคุมการเรียกตัวตรวจจับ หากเฟรมวิดีโอใหม่ พร้อมใช้งานขณะที่ตัวตรวจจับกำลังทำงาน ให้ทิ้งเฟรมนั้น ดูคลาส VisionProcessorBase ในแอปตัวอย่างเริ่มต้นใช้งานเพื่อดูตัวอย่าง
  • หากใช้ API ของ CameraX ให้ตรวจสอบว่าได้ตั้งค่ากลยุทธ์การควบคุมปริมาณข้อมูลย้อนกลับเป็นค่าเริ่มต้น ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST ซึ่งจะรับประกันว่าระบบจะส่งรูปภาพเพียงรูปเดียวสำหรับการวิเคราะห์ในแต่ละครั้ง หากมีการสร้างรูปภาพเพิ่มเติมเมื่อตัววิเคราะห์ไม่ว่าง ระบบจะทิ้งรูปภาพเหล่านั้นโดยอัตโนมัติและไม่จัดคิวเพื่อส่ง เมื่อปิดรูปภาพที่กำลังวิเคราะห์โดยการเรียก ImageProxy.close() ระบบจะส่งรูปภาพล่าสุดถัดไป
  • หากใช้เอาต์พุตของตัวตรวจจับเพื่อซ้อนทับกราฟิกบน รูปภาพอินพุต ให้รับผลลัพธ์จาก ML Kit ก่อน จากนั้นแสดงรูปภาพ และซ้อนทับในขั้นตอนเดียว ซึ่งจะแสดงผลไปยังพื้นผิวการแสดงผล เพียงครั้งเดียวสำหรับเฟรมอินพุตแต่ละเฟรม ดูคลาส CameraSourcePreview และ GraphicOverlay ในแอปตัวอย่างเริ่มต้นใช้งานเพื่อดูตัวอย่าง
  • หากใช้ Camera2 API ให้จับภาพใน ImageFormat.YUV_420_888 รูปแบบ หากใช้ Camera API เวอร์ชันเก่า ให้จับภาพใน ImageFormat.NV21 รูปแบบ