Wykrywaj, śledź i klasyfikuj obiekty za pomocą niestandardowego modelu klasyfikacji na Androidzie.

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

Gdy przekażesz obraz do ML Kit, usługa wykryje na nim maksymalnie 5 obiektów oraz ich położenie. Podczas wykrywania obiektów w strumieniach wideo każdy obiekt ma unikalny identyfikator, którego możesz używać do śledzenia obiektu w kolejnych klatkach.

Do klasyfikowania wykrytych obiektów możesz użyć niestandardowego modelu klasyfikacji obrazów. Więcej informacji o wymaganiach dotyczących zgodności modeli, o tym, gdzie znaleźć wstępnie wytrenowane modele, i o tym, jak wytrenować własne modele, znajdziesz w artykule Modele niestandardowe w ML Kit.

Istnieją 2 sposoby integracji modelu niestandardowego. Możesz połączyć model, umieszczając go w folderze zasobów aplikacji, lub pobrać go dynamicznie z Cloud Storage. W tabeli poniżej porównujemy te 2 opcje.

Model połączony Model hostowany
Model jest częścią pliku APK aplikacji, co zwiększa jego rozmiar. Model nie jest częścią pliku APK. Jest hostowany przez przesłanie do Cloud Storage. Zalecamy używanie Cloud Storage dla Firebase.
Model jest dostępny od razu, nawet gdy urządzenie z Androidem jest offline. Aplikacja musi zawierać kod umożliwiający pobieranie modelu na żądanie.
Nie jest wymagany projekt w Firebase. Wymaga projektu w Firebase (jeśli używasz Cloud Storage dla Firebase).
Aby zaktualizować model, musisz ponownie opublikować aplikację. Wysyłaj aktualizacje modelu bez ponownego publikowania aplikacji.
Brak wbudowanych testów A/B. Testy A/B z użyciem Zdalnej konfiguracji Firebase.

Wypróbuj

  • Przykład użycia modelu połączonego znajdziesz w aplikacji z krótkiego wprowadzenia do usługi Vision, a przykład użycia modelu hostowanego – w aplikacji z krótkiego wprowadzenia do AutoML.
  • Kompletną implementację tego interfejsu API znajdziesz w aplikacji demonstracyjnej Material Design.

Zanim zaczniesz

1. W pliku build.gradle.kts na poziomie projektu upewnij się, że repozytorium Google Maven jest uwzględnione w sekcjach buildscript i allprojects.

  1. Dodaj zależności bibliotek ML Kit na Androida do pliku Gradle na poziomie modułu (aplikacji), który zwykle ma nazwę app/build.gradle.kts:

    Aby połączyć model z aplikacją:

    dependencies {
  // ...
  // Object detection & tracking feature with custom bundled model
  implementation("com.google.mlkit:object-detection-custom:17.0.2")
}

  2. Jeśli chcesz pobrać model z Cloud Storage dla Firebase, upewnij się, że dodasz Firebase do projektu aplikacji na Androida, jeśli jeszcze tego nie zrobiłeś. Nie jest to wymagane, gdy łączysz model.

1. Wczytaj model

Model możesz wczytać ze źródła połączonego lokalnie lub ze źródła hostowanego zdalnie.

Konfigurowanie lokalnego źródła modelu

Aby połączyć model z aplikacją:

  1. Skopiuj plik modelu (zwykle kończący się na .tflite lub .lite) do folderu assets/ aplikacji. (Może być konieczne utworzenie folderu. W tym celu kliknij prawym przyciskiem myszy folder app/, a potem kliknij Nowy > Folder > Folder zasobów).

  2. Utwórz obiekt LocalModel, określając ścieżkę do pliku modelu:

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

Konfigurowanie zdalnie hostowanego źródła modelu

Aby używać modelu hostowanego zdalnie, musisz pobrać plik modelu do pamięci lokalnej urządzenia za pomocą własnej logiki aplikacji, a następnie wczytać go jako model lokalny. Do hostowania modelu zalecamy używanie Cloud Storage dla Firebase. Szczegóły implementacji znajdziesz w przewodniku po migracji z Firebase ML do Cloud Storage.

2. Konfigurowanie detektora obiektów

Po skonfigurowaniu źródeł modelu skonfiguruj detektor obiektów na potrzeby swojego przypadku użycia za pomocą obiektu CustomObjectDetectorOptions. Możesz zmienić te ustawienia:

Ustawienia detektora obiektów
Tryb wykrywania STREAM_MODE (domyślny) | SINGLE_IMAGE_MODE

W trybie STREAM_MODE (domyślnym) detektor obiektów działa z krótkim czasem oczekiwania, ale przy pierwszych kilku wywołaniach może zwracać niepełne wyniki (np. nieokreślone ramki ograniczające lub etykiety kategorii). W trybie STREAM_MODE, detektor przypisuje też do obiektów identyfikatory śledzenia, których możesz używać do śledzenia obiektów w kolejnych klatkach. Używaj tego trybu, gdy chcesz śledzić obiekty lub gdy ważny jest krótki czas oczekiwania, np. podczas przetwarzania strumieni wideo w czasie rzeczywistym.

W trybie SINGLE_IMAGE_MODE detektor obiektów zwraca wynik po określeniu ramki ograniczającej obiektu. Jeśli włączysz też klasyfikację, detektor zwróci wynik, gdy będą dostępne zarówno ramka ograniczająca , jak i etykieta kategorii. W rezultacie, czas oczekiwania na wykrycie może być dłuższy. W trybie SINGLE_IMAGE_MODE nie są też przypisywane identyfikatory śledzenia. Używaj tego trybu, jeśli czas oczekiwania nie jest krytyczny i nie chcesz mieć do czynienia z częściowymi wynikami.
Wykrywanie i śledzenie wielu obiektów false (domyślne) | true

Czy wykrywać i śledzić maksymalnie 5 obiektów, czy tylko najbardziej widoczny obiekt (domyślnie).
Klasyfikowanie obiektów false (domyślne) | true

Czy klasyfikować wykryte obiekty za pomocą podanego modelu klasyfikatora niestandardowego. Aby używać niestandardowego modelu klasyfikacji model, musisz ustawić tę wartość na true.

Próg ufności klasyfikacji

Minimalny wynik ufności wykrytych etykiet. Jeśli nie zostanie ustawiony, będzie używany próg klasyfikatora określony w metadanych modelu. Jeśli model nie zawiera metadanych lub metadane nie określają progu klasyfikatora, będzie używany domyślny próg 0,0.

Maksymalna liczba etykiet na obiekt

Maksymalna liczba etykiet na obiekt, które zwróci detektor. Jeśli nie zostanie ustawiony, będzie używana wartość domyślna 10.

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

  • Wykrywanie i śledzenie w czasie rzeczywistym najbardziej widocznego obiektu w wizjerze aparatu.
  • Wykrywanie wielu obiektów na obrazie statycznym.

Aby skonfigurować interfejs API na potrzeby tych przypadków użycia za pomocą modelu połą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 jego uruchomieniem musisz sprawdzić, czy został pobrany.

Chociaż musisz to potwierdzić tylko przed uruchomieniem detektora, jeśli masz zarówno model hostowany zdalnie, jak i model połączony lokalnie, warto przeprowadzić to sprawdzenie podczas tworzenia instancji detektora obrazów: utwórz detektor na podstawie modelu zdalnego, jeśli został pobrany, a w przeciwnym razie na podstawie modelu lokalnego.

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

Jeśli masz tylko model hostowany zdalnie, wyłącz funkcje związane z modelem (np. wyszarz lub ukryj część interfejsu) do czasu potwierdzenia, że model został pobrany.

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. Przygotuj obraz wejściowy

Utwórz obiekt InputImage na podstawie obrazu. Detektor obiektów działa bezpośrednio na podstawie obiektu Bitmap, obiektu ByteBuffer w formacie NV21 lub obiektu media.Image w formacie YUV_420_888. Jeśli masz bezpośredni dostęp do jednego z tych źródeł, zalecamy utworzenie obiektu InputImage na jego podstawie. Jeśli utworzysz obiekt InputImage na podstawie innych źródeł, zajmiemy się konwersją wewnętrznie, ale może to być mniej wydajne.

Obiekt InputImage możesz utworzyć na podstawie różnych źródeł. Każde z nich opisujemy poniżej.

Używanie obiektu media.Image

Aby utworzyć obiekt InputImage na podstawie obiektu media.Image, np. gdy robisz zdjęcie aparatem urządzenia, przekaż obiekt media.Image i obrót obrazu do InputImage.fromMediaImage().

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

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 w 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 przekaż obiekt media.Image i wartość stopnia 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 na podstawie identyfikatora URI pliku, przekaż kontekst aplikacji i identyfikator URI pliku do InputImage.fromFilePath().InputImage Jest to przydatne, gdy używasz intencji ACTION_GET_CONTENT, aby poprosić użytkownika o wybranie obrazu z aplikacji 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();
}

Używanie obiektu ByteBuffer lub ByteArray

Aby utworzyć obiekt InputImage na podstawie obiektu ByteBuffer lub ByteArray, najpierw oblicz stopień obrotu obrazu zgodnie z opisem w przypadku danych wejściowych media.Image. Następnie utwórz obiekt InputImage za pomocą bufora lub tablicy oraz wysokości, szerokości, formatu kodowania kolorów i stopnia obrotu obrazu:

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 obiektu Bitmap

Aby utworzyć obiekt InputImage na podstawie obiektu Bitmap, użyj tej deklaracji:

Kotlin

val image = InputImage.fromBitmap(bitmap, 0)

Java

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

Obraz jest reprezentowany przez obiekt Bitmap wraz ze stopniami obrotu.

4. Uruchom detektor 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. Uzyskaj informacje o obiektach oznaczonych etykietami

Jeśli wywołanie process() się powiedzie, do odbiornika sukcesu zostanie przekazana lista obiektów DetectedObject.

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

Ramka ograniczająca Obiekt Rect wskazujący położenie obiektu na obrazie.
Identyfikator śledzenia Liczba całkowita, która identyfikuje obiekt na obrazach. W trybie SINGLE_IMAGE_MODE ma wartość null.
Etykiety
Opis etykiety Tekstowy opis etykiety. Zwracany tylko wtedy, gdy metadane modelu LiteRT zawierają opisy etykiet.
Indeks etykiety Indeks etykiety wśród wszystkich etykiet obsługiwanych przez klasyfikator.
Ufność etykiety Poziom ufności klasyfikacji obiektu.

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

Zapewnianie wygody użytkownikom

Aby zapewnić użytkownikom jak największy komfort, postępuj zgodnie z tymi wskazówkami:

  • Skuteczność wykrywania obiektów zależy od ich złożoności wizualnej. Aby można było wykryć obiekty z niewielką liczbą cech wizualnych, mogą one zajmować większą część obrazu. Powinieneś(-aś) poinformować użytkowników, jak robić zdjęcia, które dobrze sprawdzają się w przypadku obiektów, które chcesz wykrywać.
  • Jeśli używasz klasyfikacji i chcesz wykrywać obiekty, które nie pasują do obsługiwanych kategorii, zaimplementuj specjalną obsługę nieznanych obiektów.

Zapoznaj się też z aplikacją demonstracyjną ML Kit Material Design i zbiorem wzorców Material Design dla funkcji opartych na uczeniu maszynowym.

Zwiększanie skuteczności

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

  • Jeśli używasz trybu strumieniowego w aplikacji działającej w czasie rzeczywistym, nie używaj wykrywania wielu obiektów, ponieważ większość urządzeń nie będzie w stanie zapewnić odpowiedniej liczby klatek na sekundę.

  • Jeśli używasz interfejsu API Camera lub camera2, ograniczaj wywołania detektora. Jeśli podczas działania detektora pojawi się nowa klatka wideo, pomiń ją. Przykład znajdziesz w klasie VisionProcessorBase w przykładowej aplikacji z krótkiego wprowadzenia.
  • Jeśli używasz interfejsu API CameraX, upewnij się, że strategia backpressure jest ustawiona na wartość domyślną ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST. Gwarantuje to, że do analizy będzie dostarczany tylko 1 obraz naraz. Jeśli podczas pracy analizatora zostanie wygenerowanych więcej obrazów, zostaną one automatycznie pominięte i nie zostaną dodane do kolejki dostarczania. Gdy obraz analizowany zostanie zamknięty przez wywołanie ImageProxy.close(), zostanie dostarczony następny najnowszy obraz.
  • Jeśli używasz danych wyjściowych detektora do nakładania grafiki na obraz wejściowy, najpierw uzyskaj wynik z ML Kit, a potem w jednym kroku wyrenderuj obraz i nałóż na niego grafikę. Dzięki temu renderowanie na powierzchni wyświetlacza odbywa się tylko raz na każdą klatkę wejściową. Przykład znajdziesz w klasach CameraSourcePreview i GraphicOverlay w przykładowej aplikacji z krótkiego wprowadzenia.
  • Jeśli używasz interfejsu Camera2 API, rób zdjęcia w ImageFormat.YUV_420_888 formacie. Jeśli używasz starszego interfejsu Camera API, rób zdjęcia w ImageFormat.NV21 formacie.