Wykrywanie i śledzenie obiektów za pomocą ML Kit na Androidzie

Za pomocą ML Kit możesz wykrywać i śledzić obiekty w kolejnych klatkach wideo.

Gdy przekażesz obraz do ML Kit, wykryje on na nim maksymalnie 5 obiektów wraz z ich pozycją na zdjęciu. Podczas wykrywania obiektów w strumieni wideo, każdy obiekt ma unikalny identyfikator, którego możesz użyć do śledzenia od klatki do ramki. Opcjonalnie możesz też włączyć ogólną klasyfikację obiektów, która oznacza obiekty opisami ogólnych kategorii.

Wypróbuj

Zanim zaczniesz

  1. W pliku build.gradle na poziomie projektu uwzględnij repozytorium Maven firmy Google w sekcjach buildscript i allprojects.
  2. Dodaj zależności bibliotek ML Kit na Androida do biblioteki modułu plik Gradle na poziomie aplikacji, który zwykle ma wartość app/build.gradle: 
    dependencies {
  // ...

  implementation 'com.google.mlkit:object-detection:17.0.2'

}

1. Konfigurowanie detektora obiektów

Aby wykrywać i śledzić obiekty, najpierw utwórz instancję klasy ObjectDetector i opcjonalnie określ ustawienia detektora, które chcesz zmienić w stosunku do domyślnych.

  1. Skonfiguruj detektor obiektów na potrzeby swojego przypadku użycia za pomocą ObjectDetectorOptions obiekt. Możesz zmienić te ustawienia:

    Ustawienia funkcji wykrywania obiektów
    Tryb wykrywania STREAM_MODE (domyślna) | SINGLE_IMAGE_MODE

    W STREAM_MODE (domyślnie) działa wykrywacz obiektów. z małym czasem oczekiwania, ale mogą one dawać niepełne wyniki (np. nieokreślone ramki ograniczające lub etykiety kategorii) na pierwszych kilku na wywołania detektora. Poza tym za STREAM_MODE przypisuje do obiektów identyfikatory śledzenia, których można używać śledzić obiekty w ramkach. Użyj tego trybu, jeśli chcesz śledzić lub gdy ważne jest małe opóźnienie, np. podczas przetwarzania strumieniowania wideo w czasie rzeczywistym.

    W funkcji SINGLE_IMAGE_MODE wykrywacz obiektów zwraca wynik po określeniu ramki obiektu. Jeśli także włącz klasyfikację, ponieważ zwraca wynik po ograniczeniu pole i etykieta kategorii są dostępne. W związku z tym opóźnienie wykrywania jest potencjalnie większe. Ponadto w przypadku SINGLE_IMAGE_MODE identyfikatory śledzenia nie są przypisywane. Użyj w tym trybie, jeśli opóźnienia nie są krytyczne i nie chcesz częściowe wyniki.
    Wykrywanie i śledzenie wielu obiektów false (domyślna) | true

    Określa, czy można wykryć i śledzić do pięciu obiektów, czy tylko najbardziej. widoczny obiekt (domyślnie).
    Klasyfikowanie obiektów false (domyślnie) | true

    Określa, czy należy sklasyfikować wykryte obiekty w przybliżonych kategoriach. Po włączeniu detektor obiektów klasyfikuje obiekty według tych kategorii: odzież, żywność, sprzęt do domu, miejsca i rośliny.

    Interfejs API wykrywania i śledzenia obiektów jest zoptymalizowany pod kątem tych dwóch podstawowych zastosowań przypadki:

    • Wykrywanie i śledzenie w czasie rzeczywistego czasu najbardziej widocznego obiektu w polu widzenia aparatu.
    • Wykrywanie wielu obiektów na obrazie statycznym.

    Aby skonfigurować interfejs API pod kątem tych przypadków użycia:

    Kotlin

    // Live detection and tracking
val options = ObjectDetectorOptions.Builder()
        .setDetectorMode(ObjectDetectorOptions.STREAM_MODE)
        .enableClassification()  // Optional
        .build()

// Multiple object detection in static images
val options = ObjectDetectorOptions.Builder()
        .setDetectorMode(ObjectDetectorOptions.SINGLE_IMAGE_MODE)
        .enableMultipleObjects()
        .enableClassification()  // Optional
        .build()

    Java

    // Live detection and tracking
ObjectDetectorOptions options =
        new ObjectDetectorOptions.Builder()
                .setDetectorMode(ObjectDetectorOptions.STREAM_MODE)
                .enableClassification()  // Optional
                .build();

// Multiple object detection in static images
ObjectDetectorOptions options =
        new ObjectDetectorOptions.Builder()
                .setDetectorMode(ObjectDetectorOptions.SINGLE_IMAGE_MODE)
                .enableMultipleObjects()
                .enableClassification()  // Optional
                .build();

  2. Pobierz instancję ObjectDetector:

    Kotlin

    val objectDetector = ObjectDetection.getClient(options)

    Java

    ObjectDetector objectDetector = ObjectDetection.getClient(options);

2. Przygotowywanie obrazu wejściowego

Aby wykrywać i śledzić obiekty, przekaż obrazy do metody ObjectDetector instancji process().

Wykrywacz obiektów działa bezpośrednio z Bitmap, NV21 ByteBuffer lub YUV_420_888 media.Image. Tworzę element InputImage z tych źródeł są zalecane, jeśli masz do nich bezpośredni dostęp. Jeśli InputImage pochodzi z innych źródeł, konwersję przetwarzamy wewnętrznie, co może być mniej wydajne.

W przypadku każdego klatki filmu lub obrazu w sekwencji wykonaj te czynności:

Obiekt InputImage możesz utworzyć z różnych źródeł. Każde z nich opisane jest poniżej.

Korzystanie z media.Image

Aby utworzyć obiekt InputImage na podstawie obiektu media.Image, na przykład podczas robienia zdjęcia za pomocą aparatu urządzenia, przekaż obiekt media.Image i obrót obrazu do obiektu InputImage.fromMediaImage().

Jeśli używasz tagu CameraX, OnImageCapturedListener oraz ImageAnalysis.Analyzer klasy obliczają wartość rotacji dla Ciebie.

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

Jeśli nie używasz biblioteki aparatu, która podaje stopień obrotu obrazu, możesz go obliczyć na podstawie stopnia obrotu urządzenia i orientacji czujnika aparatu na urządzeniu:

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
}
MLKitVisionImage.kt

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

Następnie przekaż obiekt media.Image oraz wartość stopnia obrotu na InputImage.fromMediaImage():

Kotlin

val image = InputImage.fromMediaImage(mediaImage, rotation)
MLKitVisionImage.kt

Java

InputImage image = InputImage.fromMediaImage(mediaImage, rotation);

Za pomocą identyfikatora URI pliku

Aby utworzyć InputImage obiektu z identyfikatora URI pliku, przekaż kontekst aplikacji oraz identyfikator URI pliku do InputImage.fromFilePath() Jest to przydatne, gdy używasz intencjonalnego wywołania ACTION_GET_CONTENT, aby poprosić użytkownika o wybranie obrazu z aplikacji Galeria.

Kotlin

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

Java

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

Używanie ByteBuffer lub ByteArray

Aby utworzyć InputImage obiektu z ByteBuffer lub ByteArray, najpierw oblicz wartość obrazu stopień obrotu zgodnie z wcześniejszym opisem dla danych wejściowych media.Image. Następnie utwórz obiekt InputImage z buforem lub tablicą wraz z wysokość, szerokością, formatem kodowania kolorów i stopniem obrotu obrazu:

Kotlin

val image = InputImage.fromByteBuffer(
        byteBuffer,
        /* image width */ 480,
        /* image height */ 360,
        rotationDegrees,
        InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12
)
MLKitVisionImage.kt

// Or:
val image = InputImage.fromByteArray(
        byteArray,
        /* image width */ 480,
        /* image height */ 360,
        rotationDegrees,
        InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12
)

MLKitVisionImage.kt

Java

InputImage image = InputImage.fromByteBuffer(byteBuffer,
        /* image width */ 480,
        /* image height */ 360,
        rotationDegrees,
        InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12
);
MLKitVisionImage.java

// Or:
InputImage image = InputImage.fromByteArray(
        byteArray,
        /* image width */480,
        /* image height */360,
        rotation,
        InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12
);
MLKitVisionImage.java

Korzystanie z: Bitmap

Aby utworzyć InputImage z obiektu Bitmap, wypełnij tę deklarację:

Kotlin

val image = InputImage.fromBitmap(bitmap, 0)
MLKitVisionImage.kt

Java

InputImage image = InputImage.fromBitmap(bitmap, rotationDegree);
MLKitVisionImage.java

Obraz jest reprezentowany przez obiekt Bitmap wraz z informacją o obróceniu w stopniach.

3. Przetwarzanie obrazu

Przekaż obraz do metody process():

Kotlin

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

Java

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