Wykrywanie, śledzenie i klasyfikowanie obiektów za pomocą niestandardowej modelu klasyfikacji na urządzeniach z Androidem

Zadbaj o dobrą organizację dzięki kolekcji Zapisuj i kategoryzuj treści zgodnie ze swoimi preferencjami.
Za pomocą ML Kit możesz wykrywać i śledzić obiekty w kolejnych klatkach wideo.

Gdy przekazujesz obraz do pakietu ML Kit, wykrywa on maksymalnie 5 obiektów wraz ze pozycją każdego obiektu na obrazie. Podczas wykrywania obiektów w strumieniach wideo każdy obiekt ma unikalny identyfikator, który umożliwia śledzenie obiektu w kolejnych klatkach.

Do klasyfikowania wykrytych obiektów możesz użyć niestandardowego modelu klasyfikacji obrazów. Aby dowiedzieć się, jakie są wymagania dotyczące zgodności z modelami oraz jak znaleźć wytrenowane modele i jak wytrenować własne, zapoznaj się z sekcją Modele niestandardowe z zestawem ML.

Model niestandardowy można zintegrować na 2 sposoby. Możesz połączyć model, umieszczając go w folderze zasobów aplikacji lub dynamicznie pobierać go z Firebase. Poniższa tabela zawiera porównanie tych 2 opcji.

Model w pakiecie Model hostowany
Model jest częścią pliku APK Twojej aplikacji, co zwiększa jego rozmiar. Model nie jest częścią Twojego pliku APK. Znajduje się w niej przesyłanie informacji do systemów uczących się Firebase.
Model jest dostępny od razu, nawet gdy urządzenie z Androidem jest offline Model jest pobierany na żądanie
Nie ma potrzeby tworzenia projektu Firebase Wymaga projektu Firebase
Aby zaktualizować model, musisz ponownie opublikować aplikację Przesyłanie aktualizacji modeli bez ponownego publikowania aplikacji
Brak wbudowanych testów A/B Łatwe testy A/B dzięki Zdalnej konfiguracji Firebase

Zanim zaczniesz

  1. W pliku build.gradle na poziomie projektu umieść repozytorium Maven firmy Google i w sekcjach buildscript i allprojects.

  2. Dodaj zależności do bibliotek ML Kit na Androida do swojego modułu Gradle na poziomie aplikacji, który zwykle wynosi app/build.gradle:

    Aby połączyć model z aplikacją:

    dependencies {
      // ...
      // Object detection & tracking feature with custom bundled model
      implementation 'com.google.mlkit:object-detection-custom:17.0.0'
    }
    

    Aby dynamicznie pobierać model z Firebase, dodaj zależność linkFirebase:

    dependencies {
      // ...
      // Object detection & tracking feature with model downloaded
      // from firebase
      implementation 'com.google.mlkit:object-detection-custom:17.0.0'
      implementation 'com.google.mlkit:linkfirebase:17.0.0'
    }
    
  3. Jeśli chcesz pobrać model, dodaj go do projektu na Androida, jeśli jeszcze go nie masz. Nie jest to wymagane w pakiecie.

1. Wczytywanie modelu

Skonfiguruj źródło modelu lokalnego

Aby połączyć model z aplikacją:

  1. Skopiuj plik modelu (zwykle zakończonego na .tflite lub .lite) do folderu assets/ aplikacji. Możliwe, że trzeba będzie najpierw utworzyć folder, klikając prawym przyciskiem myszy folder app/, a następnie wybrać Nowy > Folder > Folder zasobów.)

  2. Następnie dodaj do pliku build.gradle swoją aplikację w taki sposób, aby Gradle nie kompresował pliku modelu podczas tworzenia aplikacji:

    android {
        // ...
        aaptOptions {
            noCompress "tflite"
            // or noCompress "lite"
        }
    }
    

    Plik modelu zostanie dołączony do pakietu aplikacji i będzie dostępny dla ML Kit jako nieprzetworzony zasób.

  3. Utwórz obiekt LocalModel, podając ścieżkę do pliku modelu:

    Kotlin

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

    Java

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

Skonfiguruj źródło modelu hostowanego w Firebase

Aby użyć modelu hostowanego w trybie zdalnym, utwórz obiekt CustomRemoteModel przez określenie wartości FirebaseModelSource, określając nazwę przypisaną do modelu podczas jego publikowania:

Kotlin

// Specify the name you assigned in the Firebase console.
val remoteModel =
    CustomRemoteModel
        .Builder(FirebaseModelSource.Builder("your_model_name").build())
        .build()

Java

// Specify the name you assigned in the Firebase console.
CustomRemoteModel remoteModel =
    new CustomRemoteModel
        .Builder(new FirebaseModelSource.Builder("your_model_name").build())
        .build();

Następnie uruchom zadanie pobierania modelu, określając warunki, według których chcesz zezwolić na pobieranie. Jeśli model nie znajduje się na urządzeniu lub jest dostępna jego nowsza wersja, zadanie asynchronicznie pobierze model z Firebase:

Kotlin

val downloadConditions = DownloadConditions.Builder()
    .requireWifi()
    .build()
RemoteModelManager.getInstance().download(remoteModel, downloadConditions)
    .addOnSuccessListener {
        // Success.
    }

Java

DownloadConditions downloadConditions = new DownloadConditions.Builder()
        .requireWifi()
        .build();
RemoteModelManager.getInstance().download(remoteModel, downloadConditions)
        .addOnSuccessListener(new OnSuccessListener() {
            @Override
            public void onSuccess(@NonNull Task task) {
                // Success.
            }
        });

Wiele aplikacji rozpoczyna zadanie pobierania w kodzie inicjowania, ale możesz to zrobić w dowolnym momencie przed użyciem modelu.

2. Konfigurowanie wzorca do wykrywania obiektów

Gdy skonfigurujesz źródła modeli, skonfiguruj wzorzec do wykrywania treści dla użycia w obiekcie CustomObjectDetectorOptions. Możesz zmienić te ustawienia:

Ustawienia wzorca do wykrywania obiektów
Tryb wykrywania STREAM_MODE (domyślnie) | SINGLE_IMAGE_MODE

W STREAM_MODE (domyślnie) wzorzec do wykrywania obiektów działa z krótkim czasem oczekiwania, ale w pierwszych kilku wywołaniach wzorca może zwrócić niepełne wyniki (np. nieokreślone ramki ograniczające lub etykiety kategorii). Dodatkowo w STREAM_MODE wzorzec do wykrywania obiektów zostaje przypisany do obiektów w celu śledzenia obiektów w ramkach. Użyj tego trybu, jeśli chcesz śledzić obiekty lub gdy ważne jest małe opóźnienie, na przykład podczas przetwarzania strumieni wideo w czasie rzeczywistym.

W SINGLE_IMAGE_MODE wzorzec do wykrywania obiektów zwraca wynik po określeniu ramki granicznej obiektu. Jeśli włączysz także klasyfikację, zwróci ona wynik po udostępnieniu ramki ograniczenia i etykiety kategorii. W rezultacie opóźnienie wykrywania może być większe. Poza tym SINGLE_IMAGE_MODE nie ma przypisanych identyfikatorów śledzenia. Użyj tego trybu, jeśli czas oczekiwania nie jest krytyczny i nie chcesz obsługiwać częściowych wyników.

Wykrywanie i śledzenie wielu obiektów false (domyślnie) | true

Określa, czy chcesz wykrywać i śledzić maksymalnie 5 obiektów czy tylko najbardziej wyróżniony obiekt (domyślnie).

Klasyfikowanie obiektów false (domyślnie) | true

Określa, czy klasyfikować wykryte obiekty, korzystając z podanego modelu klasyfikatora niestandardowego. Aby użyć niestandardowego modelu klasyfikacji, musisz ustawić tę wartość na true.

Próg ufności klasyfikacji

Minimalny współczynnik ufności wykrytych etykiet. Jeśli jej nie skonfigurujesz, będzie używany dowolny próg klasyfikatora określony przez metadane modelu. Jeśli model nie zawiera żadnych metadanych lub metadane nie określają progu klasyfikatora, zostanie użyty domyślny próg 0,0.

Maksymalna liczba etykiet na obiekt

Maksymalna liczba etykiet na obiekt, który zostanie zwrócony przez wzorzec. Jeśli zasada nie zostanie skonfigurowana, używana będzie wartość domyślna, czyli 10.

Interfejs wykrywania i śledzenia obiektów jest zoptymalizowany pod kątem tych dwóch podstawowych przypadków użycia:

  • Wykrywanie na żywo i śledzenie najbardziej widocznego obiektu w wizjerze aparatu.
  • Wykrywanie wielu obiektów na podstawie obrazu statycznego.

Aby skonfigurować interfejs API pod kątem tych przypadków użycia, używając modelu dołączonego lokalnie:

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

Jeśli masz model hostowany zdalnie, przed uruchomieniem musisz sprawdzić, czy został pobrany. Stan zadania pobierania modelu możesz sprawdzić za pomocą metody isModelDownloaded() w menedżerze modeli.

Chociaż musisz tylko potwierdzić tę czynność przed uruchomieniem wzorca, jeśli masz zarówno model hostowany zdalnie, jak i model przechowywany w pakiecie lokalnym, w razie utworzenia instancji wzorca do wykrywania obrazu możesz zrobić to sprawdzanie. W przeciwnym razie utwórz model z modelu zdalnego, jeśli został pobrany, a w innym przypadku z modelu lokalnego.

Kotlin

RemoteModelManager.getInstance().isModelDownloaded(remoteModel)
    .addOnSuccessListener { isDownloaded ->
    val optionsBuilder =
        if (isDownloaded) {
            CustomObjectDetectorOptions.Builder(remoteModel)
        } else {
            CustomObjectDetectorOptions.Builder(localModel)
        }
    val customObjectDetectorOptions = optionsBuilder
            .setDetectorMode(CustomObjectDetectorOptions.SINGLE_IMAGE_MODE)
            .enableClassification()
            .setClassificationConfidenceThreshold(0.5f)
            .setMaxPerObjectLabelCount(3)
            .build()
    val objectDetector =
        ObjectDetection.getClient(customObjectDetectorOptions)
}

Java

RemoteModelManager.getInstance().isModelDownloaded(remoteModel)
    .addOnSuccessListener(new OnSuccessListener() {
        @Override
        public void onSuccess(Boolean isDownloaded) {
            CustomObjectDetectorOptions.Builder optionsBuilder;
            if (isDownloaded) {
                optionsBuilder = new CustomObjectDetectorOptions.Builder(remoteModel);
            } else {
                optionsBuilder = new CustomObjectDetectorOptions.Builder(localModel);
            }
            CustomObjectDetectorOptions customObjectDetectorOptions = optionsBuilder
                .setDetectorMode(CustomObjectDetectorOptions.SINGLE_IMAGE_MODE)
                .enableClassification()
                .setClassificationConfidenceThreshold(0.5f)
                .setMaxPerObjectLabelCount(3)
                .build();
            ObjectDetector objectDetector =
                ObjectDetection.getClient(customObjectDetectorOptions);
        }
});

Jeśli masz tylko model hostowany zdalnie, wyłącz funkcje powiązane z modelem (np. szary lub ukryj część interfejsu), dopóki nie potwierdzisz, że model został pobrany. Możesz to zrobić, dołączając odbiornik do menedżera modelu download():

Kotlin

RemoteModelManager.getInstance().download(remoteModel, conditions)
    .addOnSuccessListener {
        // Download complete. Depending on your app, you could enable the ML
        // feature, or switch from the local model to the remote model, etc.
    }

Java

RemoteModelManager.getInstance().download(remoteModel, conditions)
        .addOnSuccessListener(new OnSuccessListener() {
            @Override
            public void onSuccess(Void v) {
              // Download complete. Depending on your app, you could enable
              // the ML feature, or switch from the local model to the remote
              // model, etc.
            }
        });

3. Przygotowanie obrazu wejściowego

Utwórz obiekt InputImage z obrazu. Wzorzec do wykrywania obiektów działa bezpośrednio z poziomu Bitmap, NV21 ByteBuffer lub YUV_420_888 media.Image. Jeśli masz bezpośredni dostęp do jednego z tych źródeł, zalecamy utworzenie InputImage z tych źródeł. Jeśli tworzysz element InputImage z innych źródeł, przetworzymy go za Ciebie, co może być mniej efektywne.

Obiekt InputImage możesz utworzyć z różnych źródeł, a każde z nich opisano poniżej.

Używanie modułu media.Image

Aby utworzyć obiekt InputImage z obiektu media.Image, na przykład podczas robienia obrazu z aparatu urządzenia, przekaż obiekt media.Image, a obraz zostanie obrócony do InputImage.fromMediaImage().

Jeśli używasz biblioteki KameraX, klasy OnImageCapturedListener i ImageAnalysis.Analyzer obliczają wartość rotacji.

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 zdjęć, która zapewnia kąt obrotu obrazu, możesz go obliczyć na podstawie stopni obrotu urządzenia i orientacji czujnika aparatu w tym 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
}

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 prześlij obiekt media.Image i wartość stopni obrotu do InputImage.fromMediaImage():

Kotlin

val image = InputImage.fromMediaImage(mediaImage, rotation)

Java

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

Używanie identyfikatora URI pliku

Aby utworzyć obiekt InputImage z identyfikatora URI pliku, przekaż kontekst aplikacji i identyfikator pliku do InputImage.fromFilePath(). Ta opcja jest przydatna, gdy używasz intencji ACTION_GET_CONTENT zachęcającej użytkownika do wybrania zdjęcia z galerii.

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

Korzystanie z narzędzia ByteBuffer lub ByteArray

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

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

Używanie modułu Bitmap

Aby utworzyć obiekt InputImage z obiektu Bitmap, złóż tę deklarację:

Kotlin

val image = InputImage.fromBitmap(bitmap, 0)

Java

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

Obraz jest reprezentowany przez obiekt Bitmap wraz z stopniami obrotu.

4. Uruchamianie wzorca do wykrywania obiektów

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. Uzyskiwanie informacji o obiektach oznaczonych etykietą

Jeśli wywołanie metody process() zakończy się powodzeniem, detektor będzie przekazywać listę DetectedObject s.

Każdy element DetectedObject zawiera te właściwości:

Ramka ograniczająca Rect, który wskazuje pozycję obiektu na obrazie.
Identyfikator śledzenia Liczba całkowita identyfikująca obiekt na obrazach. Brak wartości SINGLE_IMAGE_MODE.
Etykiety
Opis etykiety Opis tekstowy etykiety. Zwracane tylko wtedy, gdy metadane modelu TensorFlow Lite zawierają opisy etykiet.
Indeks etykiety Indeks etykiety obejmuje wszystkie etykiety obsługiwane przez klasyfikator.
Pewność etykiety Wartość ufności klasyfikacji obiektów.

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

Dbanie o komfort użytkowników

Aby zadbać o wygodę użytkowników, postępuj zgodnie z tymi wskazówkami w aplikacji:

  • Pomyślne wykrywanie obiektów zależy od złożoności wizualnej obiektu. Aby można było wykryć obiekty, które mają niewielką liczbę funkcji wizualnych, może być konieczne zajęcie większej części obrazu. Należy przekazać użytkownikom wskazówki dotyczące przechwytywania danych wejściowych, które dobrze działają z rodzajami obiektów, które mają być wykrywane.
  • Jeśli używasz klasyfikacji, jeśli chcesz wykrywać obiekty, które nie należą do obsługiwanych kategorii, zaimplementuj specjalną obsługę na nieznanych obiektach.

Zobacz też aplikację ML Kit Material Design i wzór Material Design na potrzeby funkcji obsługiwanych przez systemy uczące się.

Improving performance

Jeśli chcesz używać wykrywania obiektów w aplikacji w czasie rzeczywistym, postępuj zgodnie z tymi wskazówkami, aby uzyskać najlepszą liczbę klatek na sekundę:

  • Gdy korzystasz z trybu strumieniowego w aplikacji w czasie rzeczywistym, nie używaj wykrywania wielu obiektów, ponieważ większość urządzeń nie jest w stanie wygenerować wystarczającej liczby klatek.

  • Jeśli używasz interfejsu Camera lub camera2 API, ograniczaj wywołania wzorca do wykrywania treści. Jeśli podczas działania wzorca do wykrywania treści dostępna jest nowa ramka wideo, upuść ją. Przykład znajdziesz w klasie VisionProcessorBase w przykładowej aplikacji.
  • Jeśli korzystasz z interfejsu API CameraX, upewnij się, że strategia ciśnienia wstecznego jest ustawiona na wartość domyślną ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST. Zapewnia to tylko jeden obraz naraz. Jeśli w analizatorze będzie dużo więcej obrazów, to będą one automatycznie usuwane i nie będą umieszczane w kolejce. Po zamknięciu analizujemy obraz, wywołując polecenie ImageProxy.close(). Następny obraz jest wyświetlany.
  • Jeśli używasz danych wyjściowych wzorca do nakładania grafiki na obraz wejściowy, najpierw uzyskaj wynik z ML Kit, a następnie wyrenderuj obraz i nakładkę w jednym kroku. W przypadku każdej klatki wejściowej jest ona renderowana tylko raz na ekranie. Przykład znajdziesz w klasach CameraSourcePreview i GraphicOverlay w przykładowej aplikacji.
  • Jeśli używasz interfejsu Camera2 API, zrób zdjęcia w formacie ImageFormat.YUV_420_888. Jeśli używasz starszego interfejsu API aparatu, zrób zdjęcia w formacie ImageFormat.NV21.