Détecter des objets dans des images avec ML Kit: Android

1. Avant de commencer

ML Kit est un SDK pour mobile qui intègre l'expertise de Google en machine learning sur les applications Android et iOS. Ses API performantes et simples d'utilisation vous permettent de résoudre les problèmes courants dans vos applications ou de créer des expériences utilisateur inédites. Toutes ces fonctionnalités reposent sur les modèles de ML de pointe de Google et sont proposées gratuitement.

Les API de ML Kit s'exécutent toutes sur l'appareil, ce qui vous permet de traiter en temps réel les cas où vous souhaitez traiter un flux vidéo en direct, par exemple. Cela signifie également que cette fonctionnalité est disponible hors connexion.

Cet atelier de programmation vous explique les étapes simples à suivre pour ajouter la détection d'objets et le suivi (ODT) d'une image donnée à votre application Android existante. Veuillez noter que cet atelier de programmation utilise quelques raccourcis pour mettre en évidence l'utilisation de la fonctionnalité ODT du ML Kit.

Objectifs de l'atelier

Dans cet atelier de programmation, vous allez créer une application Android avec ML Kit. Votre application utilisera l'API de suivi et de détection d'objets ML Kit pour détecter des objets dans une image donnée. Au final, vous devriez voir une image semblable à la droite,

Points abordés

Intégrer le SDK ML Kit dans votre application Android
API ML Kit Object Detection et Tracking

Prérequis

Une version récente d'Android Studio (version 4.1.2 ou ultérieure)
Android Emulator ou appareil Android physique
L'exemple de code
Connaissances de base en développement Android en langage Kotlin

Cet atelier de programmation porte sur ML Kit. Les concepts et les blocs de code non pertinents ne sont pas abordés, mais vous sont fournis afin que vous puissiez simplement les copier et les coller.

2. Configuration

Télécharger le code

Cliquez sur le lien ci-dessous pour télécharger l'ensemble du code de cet atelier de programmation :

Décompressez le fichier ZIP téléchargé. Cela permet de décompresser un dossier racine (mlkit-android-main) contenant toutes les ressources dont vous avez besoin. Pour cet atelier de programmation, vous n'aurez besoin que des sources dans le sous-répertoire object-detection.

Le sous-répertoire de détection d'objets du dépôt mlkit-android contient deux répertoires:

starter : code de démarrage sur lequel s'appuie cet atelier de programmation.
final : code final de l'exemple d'application terminée

3. Ajouter l'API de détection d'objets et de suivi ML Kit au projet

Importer l'application dans Android Studio

Commençons par importer l'application de départ dans Android Studio.

Ouvrez Android Studio, sélectionnez Import Project (Gradle, Eclipse ADT, etc.) (Importer un projet (Gradle, Eclipse ADT, etc.)), puis sélectionnez le dossier starter dans le code source que vous avez téléchargé précédemment.

Ajouter les dépendances nécessaires à la détection et au suivi des objets ML Kit

Les dépendances de ML Kit vous permettent d'intégrer le SDK ODT de ML Kit à votre application. Ajoutez les lignes suivantes à la fin du fichier app/build.gradle de votre projet:

build.gradle

dependencies {
  // ...
  implementation 'com.google.mlkit:object-detection:16.2.4'
}

Synchroniser votre projet avec les fichiers Gradle

Pour vous assurer que toutes les dépendances sont disponibles pour votre application, vous devez synchroniser votre projet avec les fichiers Gradle à ce stade.

Sélectionnez Sync Project with Gradle Files (Synchroniser le projet avec les fichiers Gradle) () dans la barre d'outils d'Android Studio.

(Si ce bouton est désactivé, veillez à importer uniquementstarter/app/build.gradle , et non l'intégralité du dépôt.)

4. Exécuter l'application de démarrage

Maintenant que vous avez importé le projet dans Android Studio et que vous avez ajouté les dépendances pour la détection et le suivi d'objets ML Kit, vous êtes prêt à exécuter l'application.

Connectez votre appareil Android via USB à votre hôte ou démarrez l'émulateur Android Studio, puis cliquez sur Run () (Exécuter) dans la barre d'outils Android Studio.

Exécuter et explorer l'application

L'application devrait se lancer sur votre appareil Android. Elle inclut un code récurrent permettant de prendre une photo ou de sélectionner une image prédéfinie, et de l'insérer dans un pipeline de détection et de suivi des objets que vous créerez dans cet atelier de programmation. Examinons l'application un peu avant d'écrire du code.

Tout d'abord, un bouton ( ) apparaît en bas de l'écran pour:

afficher l'application Appareil photo intégrée à votre appareil ou émulateur
prendre une photo dans l'application Appareil photo
recevoir l'image capturée dans l'application de départ ;
afficher l'image

EssayerPrendre une photo bouton "Suivre", suivez les instructions pour prendre une photoaccepter La photo s'affiche sur la photo.application de démarrage dans le menu déroulant ;

Répétez cette procédure plusieurs fois pour en savoir plus:

Deuxièmement, vous pouvez choisir parmi trois images prédéfinies. Vous pouvez utiliser ces images ultérieurement pour tester le code de détection d'objets si vous exécutez un émulateur Android.

Sélectionnez une image parmi les trois images prédéfinies. L'image s'affiche en plein écran:

5. Ajouter la détection d'objets sur l'appareil

Dans cette étape, vous allez ajouter la fonctionnalité à l'application de départ pour détecter des objets dans des images. Comme vous l'avez vu à l'étape précédente, l'application de démarrage contient un code récurrent permettant de prendre des photos avec l'application Appareil photo de l'appareil. Si vous exécutez l'atelier de programmation sur un émulateur Android, vous pouvez essayer trois images prédéfinies dans l'application :

Lorsque vous avez sélectionné une image (soit à partir des images prédéfinies, soit à partir d'une photo avec l'application Appareil photo), le code récurrent décode cette image dans une instance Bitmap. Elle s'affiche à l'écran et appelle la méthode runObjectDetection avec l'élément illustrée.

Au cours de cette étape, vous allez ajouter du code à la méthode runObjectDetection afin de détecter des objets.

Configurer et exécuter la détection d'objets sur l'appareil pour une image

Il n'y a que trois étapes simples avec trois API pour configurer le ML ODT de ML Kit:

préparer une image: InputImage
Créez un objet détecteur: ObjectDetection.getClient(options)
connectez les deux objets ci-dessus: process(image)

Vous devez procéder de cette manière dans la fonction runObjectDetection(bitmap: Bitmap) du fichier MainActivity.kt.

/**
 * ML Kit Object Detection Function
 */
private fun runObjectDetection(bitmap: Bitmap) {
}

Pour le moment, la fonction est vide. Passez aux étapes suivantes pour intégrer l'OTT du ML Kit. En attendant, Android Studio vous invite à ajouter les importations nécessaires:

com.google.mlkit.vision.common.InputImage
com.google.mlkit.vision.objects.ObjectDetection
com.google.mlkit.vision.objects.defaults.ObjectDetectorOptions

Étape 1: Créez une InputInput

ML Kit fournit une API simple pour créer un InputImage à partir d'un Bitmap. Vous pouvez ensuite insérer un InputImage dans les API ML Kit.

// Step 1: create ML Kit's InputImage object
val image = InputImage.fromBitmap(bitmap, 0)

Ajoutez le code ci-dessus en haut de runObjectDetection(bitmap:Bitmap).

Étape 2: Créez une instance de détecteur

ML Kit suit le modèle de conception de compilateur. Vous allez transmettre la configuration au compilateur, puis lui acquérir un détecteur. Vous avez le choix entre trois options de configuration (les options en gras sont utilisées dans cet atelier de programmation):

Mode détecteur (image unique ou flux)
mode de détection (un seul ou plusieurs détection d'objets ).
mode de classification (activé ou désactivé)

Cet atelier de programmation s'applique à une seule image : la détection et la classification d'objets multiples. Ajoutez-la maintenant:

// Step 2: acquire detector object
val options = ObjectDetectorOptions.Builder()
   .setDetectorMode(ObjectDetectorOptions.SINGLE_IMAGE_MODE)
   .enableMultipleObjects()
   .enableClassification()
   .build()
val objectDetector = ObjectDetection.getClient(options)

Étape 3: Ajoutez des images au détecteur

La détection et la classification des objets sont asynchrones:

Vous envoyez une image au détecteur (via process()).
Le détecteur fait tout son possible.
Le détecteur vous indique le résultat via un rappel.

C'est exactement ce que fait le code suivant (copiez-le dans le code existant dans fun runObjectDetection(bitmap:Bitmap)):)

// Step 3: feed given image to detector and setup callback
objectDetector.process(image)
   .addOnSuccessListener {
       // Task completed successfully
        debugPrint(it)
   }
   .addOnFailureListener {
       // Task failed with an exception
       Log.e(TAG, it.message.toString())
   }

Une fois l'opération terminée, le détecteur vous avertit par:

Nombre total d'objets détectés. Chaque objet détecté est décrit avec les éléments suivants:
trackingId: nombre entier que vous utilisez pour effectuer le suivi de plusieurs images (PAS utilisé dans cet atelier de programmation).
boundingBox: cadre de délimitation de l'objet.
labels: liste d'étiquettes pour l'objet détecté (uniquement lorsque la classification est activée):
index (obtenir l'index de ce libellé)
text (ajoutez le texte de cette étiquette, y compris "Fashion Goods", "Food", "Home Goods", "Place", "Plant")
confidence ( une valeur flottante comprise entre 0 et 1,0 avec 1,0 signifie 100%)

Vous avez probablement remarqué que le code effectue un traitement imprimable du résultat détecté avec debugPrint().

Ajoutez-le à la classe MainActivity:

private fun debugPrint(detectedObjects: List<DetectedObject>) {
   detectedObjects.forEachIndexed { index, detectedObject ->
       val box = detectedObject.boundingBox

       Log.d(TAG, "Detected object: $index")
       Log.d(TAG, " trackingId: ${detectedObject.trackingId}")
       Log.d(TAG, " boundingBox: (${box.left}, ${box.top}) - (${box.right},${box.bottom})")
       detectedObject.labels.forEach {
           Log.d(TAG, " categories: ${it.text}")
           Log.d(TAG, " confidence: ${it.confidence}")
       }
   }
}

Vous êtes maintenant prêt à accepter des images pour la détection.

Exécutez l'atelier de programmation en cliquant sur Run (Exécuter) () dans la barre d'outils d'Android Studio. Sélectionnez une image prédéfinie ou prenez une photo, puis regardezFenêtre logcat(). dans l'IDE.

Le résultat doit ressembler à ceci :

D/MLKit Object Detection: Detected object: 0
D/MLKit Object Detection:  trackingId: null
D/MLKit Object Detection:  boundingBox: (481, 2021) - (2426,3376)
D/MLKit Object Detection:  categories: Food
D/MLKit Object Detection:  confidence: 0.90234375
D/MLKit Object Detection: Detected object: 1
D/MLKit Object Detection:  trackingId: null
D/MLKit Object Detection:  boundingBox: (2639, 2633) - (3058,3577)
D/MLKit Object Detection: Detected object: 2
D/MLKit Object Detection:  trackingId: null
D/MLKit Object Detection:  boundingBox: (3, 1816) - (615,2597)
D/MLKit Object Detection:  categories: Home good
D/MLKit Object Detection:  confidence: 0.75390625

...ce qui signifie que le détecteur a détecté trois objets:

Les catégories sont Alimentation et Maison.
Aucune catégorie renvoyée pour le second, car il s'agit d'une classe inconnue.
Aucune trackingId (car il s'agit du mode de détection d'images unique).
Position à l'intérieur du rectangle boundingBox (par exemple, (481, 2021) (2426, 3376))
Le détecteur est certain que le premier correspond à un aliment (à 90 %, à savoir une salade).

Techniquement, vous n'avez besoin que de la détection d'objets ML Kit pour le moment. Félicitations !

C'est toujours au niveau de l'interface utilisateur : vous êtes toujours à l'étape de démarrage, mais vous pouvez utiliser les résultats détectés dans l'interface utilisateur, par exemple pour tracer le cadre de délimitation afin d'améliorer l'expérience : passons à l'étape suivante, qui consiste à post-traiter. les résultats détectés.

6. Post-traiter les résultats de détection

Au cours des étapes précédentes, vous avez imprimé le résultat détecté dans logcat: c'est simple et rapide.

Dans cette section, vous allez utiliser le résultat dans l'image:

dessiner le cadre de délimitation sur l'image
indiquer le nom de la catégorie et la confiance dans le cadre de délimitation

Comprendre les utilitaires de visualisation

L'atelier de programmation inclut un code récurrent permettant de visualiser le résultat de la détection. Utilisez ces utilitaires pour simplifier le code de visualisation:

data class BoxWithText(val box: Rect, val text: String) Cette classe de données permet de stocker un résultat de détection d'objets à des fins de visualisation. box est le cadre de délimitation dans lequel se trouve l'objet et text est la chaîne de résultat de la détection à afficher avec le cadre de délimitation de l'objet.
fun drawDetectionResult(bitmap: Bitmap, detectionResults: List<BoxWithText>): Bitmap Cette méthode dessine les résultats de la détection d'objets dans detectionResults sur l'entrée bitmap et renvoie la copie modifiée de celle-ci.

Voici un exemple de résultat de la méthode utilitaire drawDetectionResult:

Visualiser le résultat de la détection ML Kit

Utilisez les utilitaires de visualisation pour dessiner le résultat de la détection d'objets ML Kit au-dessus de l'image d'entrée.

Accédez à l'emplacement où vous appelez debugPrint() et ajoutez l'extrait de code suivant en dessous:

// Parse ML Kit's DetectedObject and create corresponding visualization data
val detectedObjects = it.map { obj ->
    var text = "Unknown"

    // We will show the top confident detection result if it exist
    if (obj.labels.isNotEmpty()) {
        val firstLabel = obj.labels.first()
        text = "${firstLabel.text}, ${firstLabel.confidence.times(100).toInt()}%"
    }
    BoxWithText(obj.boundingBox, text)
}

// Draw the detection result on the input bitmap
val visualizedResult = drawDetectionResult(bitmap, detectedObjects)

// Show the detection result on the app screen
runOnUiThread {
    inputImageView.setImageBitmap(visualizedResult)
}

Vous allez commencer par analyser le DetectedObject du ML Kit et créer une liste d'objets BoxWithText pour afficher le résultat de la visualisation.
Vous allez ensuite dessiner le résultat de la détection sur l'image d'entrée, à l'aide de la méthode utilitaire drawDetectionResult, puis l'afficher à l'écran.

Exécuter le code

Cliquez sur Run (Exécuter) () dans la barre d'outils d'Android Studio.

Une fois l'application chargée, appuyez sur le bouton avec l'icône de l'appareil photo, dirigez l'appareil photo vers un objet, prenez une photo, acceptez la photo (dans l'application Appareil photo) ou appuyez simplement sur une image prédéfinie. Les résultats de détection doivent s'afficher. Appuyez de nouveau sur le bouton ou sélectionnez une autre image pour répéter l'exécution du dernier ML Kit.

7. Félicitations !

Vous avez utilisé ML Kit pour ajouter des fonctionnalités de détection d'objets à votre application:

Trois étapes avec trois API
Créer une image d'entrée
Créer un détecteur
Envoyer l'image au détecteur

Vous avez terminé la configuration.

Vous pouvez améliorer le modèle au fur et à mesure que le modèle par défaut ne reconnaît que cinq catégories (il ne connaît même pas les couteaux, la fourchette et les bouteilles). Consultez l'autre atelier de programmation sur les parcours de formation sur le machine learning sur l'appareil pour détecter un objet afin d'entraîner un modèle personnalisé.

Points abordés

Ajouter le suivi des objets et le suivi ML Kit à votre application Android
Utiliser la détection et le suivi d'objets sur l'appareil dans ML Kit pour détecter des objets dans des images

Étapes suivantes

Exploitez tout le potentiel de ML Kit ODT avec des images et des vidéos en direct pour améliorer la détection et la classification
Consultez le parcours de formation sur la détection d'objets sur l'appareil pour apprendre à entraîner un modèle personnalisé.
Appliquer le SDK ODT de ML Kit dans votre propre application Android

En savoir plus

https://developers.google.com/ml-kit/vision/object-detection