Rileva oggetti nelle immagini con ML Kit: Android

1. Prima di iniziare

ML Kit è un SDK mobile che porta l'esperienza di Google in materia di machine learning on-device alle app per Android e iOS. Puoi utilizzare le API Vision e Natural Language, potenti ma semplici da utilizzare, per risolvere sfide comuni nelle tue app o creare esperienze utente completamente nuove. Tutti sfruttano i migliori modelli di ML di Google e ti vengono offerti senza costi.

Le API di ML Kit vengono tutte eseguite sul dispositivo, consentendo ad esempio casi d'uso in tempo reale in cui si vuole elaborare uno stream in diretta della videocamera. Ciò significa anche che la funzionalità è disponibile offline.

Questo codelab ti guiderà attraverso semplici passaggi per aggiungere il rilevamento e il monitoraggio degli oggetti (ODT) per una determinata immagine nella tua app per Android esistente. Tieni presente che questo codelab richiede alcune scorciatoie per evidenziare l'utilizzo di ML Kit ODT.

Cosa creerai

In questo codelab, creerai un'app per Android con ML Kit. L'app utilizzerà l'API ML Kit Object Detection and Tracking per rilevare oggetti in una determinata immagine.Alla fine, dovresti vedere qualcosa di simile all'immagine a destra.

Cosa imparerai a fare

  • Come integrare l'SDK ML Kit nella tua applicazione Android
  • API ML Kit Object Detection and Tracking

Che cosa ti serve

  • Una versione recente di Android Studio (v4.1.2 o successiva)
  • Emulatore di Android Studio o un dispositivo Android fisico
  • Il codice campione
  • Conoscenza di base dello sviluppo Android in Kotlin

Questo codelab è incentrato su ML Kit. Concetti e blocchi di codice non pertinenti sono trattati solo superficialmente e sono forniti solo per operazioni di copia e incolla.

2. Configurazione

Scarica il codice

Fai clic sul seguente link per scaricare tutto il codice per questo codelab:

Apri il file ZIP scaricato. Verrà aperta una cartella principale (mlkit-android-main) con tutte le risorse di cui hai bisogno. Per questo codelab, sono necessarie solo le sorgenti nella sottodirectory object-detection.

La sottodirectory di rilevamento degli oggetti nel repository mlkit-android contiene due directory:

  • android_studio_folder.pngcomando iniziale: codice iniziale che crei per questo codelab.
  • android_studio_folder.pngfinal: codice completato per l'app di esempio completata.

3. Aggiungi l'API ML Kit Object Detection and Tracking al progetto

Importare l'app in Android Studio

Inizia importando l'app iniziale in Android Studio.

Apri Android Studio, seleziona Import Project (Gradle, Eclipse ADT ecc.) e scegli la cartella starter dal codice sorgente che hai scaricato in precedenza.

7c0f27882a2698ac.png

Aggiungere le dipendenze per il rilevamento e il monitoraggio degli oggetti ML Kit

Le dipendenze del kit ML consentono di integrare l'SDK ODT ML Kit nella tua app. Aggiungi le seguenti righe alla fine del file app/build.gradle del tuo progetto:

build.gradle

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

Sincronizza il tuo progetto con i file Gradle

Per assicurarti che tutte le dipendenze siano disponibili per la tua app, a questo punto devi sincronizzare il progetto con i file Gradle.

Seleziona Sync Project with Gradle Files ( b451ab2d04d835f9.png) dalla barra degli strumenti di Android Studio.

(Se questo pulsante è disabilitato, assicurati di importare solo starter/app/build.gradle , non l'intero repository.

4. Esegui l'app iniziale

Ora che hai importato il progetto in Android Studio e aggiunto le dipendenze per il rilevamento e il monitoraggio degli oggetti ML Kit, puoi eseguire l'app per la prima volta.

Collega il dispositivo Android tramite USB al tuo host oppure avvia l'emulatore Android Studio e fai clic su Esegui ( execute.png) nella barra degli strumenti di Android Studio.

Corri ed esplora l'app

L'app dovrebbe avviarsi sul tuo dispositivo Android. Ha del codice boilerplate per consentirti di scattare una foto o selezionare un'immagine preimpostata e di alimentarla a una pipeline di rilevamento e monitoraggio degli oggetti che creerai in questo codelab. Esploriamo un po' l'app prima di scrivere il codice.

Innanzitutto, c'è un Button ( c6d965d639c3646.png) in basso per:

  • visualizza l'app della fotocamera integrata nel dispositivo/emulatore
  • scattare una foto nell'app fotocamera
  • Ricevi l'immagine acquisita nell'app iniziale
  • mostra l'immagine

Prova il pulsante Scatta foto, segui le istruzioni per scattare una foto, accetta la foto e osserva come viene visualizzata nell'app iniziale.

Ripeti l'operazione alcune volte per vedere come funziona:

9ec541980dbe2d31.png 8312dde41425ba4b.png fa8492bfc1914ff0.png

In secondo luogo, puoi scegliere tra 3 immagini preimpostate. Puoi utilizzare queste immagini in un secondo momento per testare il codice di rilevamento degli oggetti se utilizzi un emulatore Android.

Seleziona un'immagine tra le 3 immagini preimpostate. Guarda che l'immagine viene mostrata nella visualizzazione più grande:

1dd41b3ec978f1d9.png

5. Aggiungi rilevamento di oggetti sul dispositivo

In questo passaggio aggiungerai la funzionalità all'app iniziale per rilevare oggetti nelle immagini. Come hai visto nel passaggio precedente, l'app iniziale contiene il codice boilerplate per scattare foto con l'app Fotocamera sul dispositivo. Nell'app sono inoltre disponibili 3 immagini preimpostate su cui puoi provare il rilevamento degli oggetti se esegui il codelab su un emulatore Android.

Dopo aver selezionato un'immagine tra le immagini preimpostate o per scattare una foto con l'app Fotocamera, il codice boilerplate decodifica l'immagine in un'istanza Bitmap, la mostra sullo schermo e chiama il metodo runObjectDetection con l'immagine.

In questo passaggio, aggiungerai codice al metodo runObjectDetection per rilevare gli oggetti.

Configurare ed eseguire il rilevamento di oggetti sul dispositivo su un'immagine

Per configurare ODT ML Kit sono necessari solo tre semplici passaggi e tre API:

  • prepara un'immagine: InputImage
  • crea un oggetto rilevatore: ObjectDetection.getClient(options)
  • collega i 2 oggetti sopra: process(image)

Puoi farlo all'interno della funzione runObjectDetection(bitmap: Bitmap) nel file MainActivity.kt.

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

Al momento la funzione è vuota. Procedi con i seguenti passaggi per implementare ML Kit ODT. Durante l'operazione, Android Studio ti chiederà di aggiungere le importazioni necessarie:

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

Passaggio 1: crea un'immagine di input

ML Kit fornisce una semplice API per creare un InputImage da un Bitmap. Poi potrai inserire un'InputImage nelle API ML Kit.

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

Aggiungi il codice riportato sopra all'inizio di runObjectDetection(bitmap:Bitmap).

Passaggio 2: crea un'istanza del rilevatore

ML Kit segue il Builder Design Pattern. Passerai la configurazione al builder, quindi acquisirai un rilevatore. Ci sono 3 opzioni di configurazione (le opzioni in grassetto vengono utilizzate in questo codelab):

  • modalità rilevatore (immagine singola o stream)
  • modalità di rilevamento (singolo o più rilevamento di oggetti)
  • modalità di classificazione (attivata o disattivata)

Questo codelab è per una singola immagine - rilevamento di più oggetti e per la classificazione. Aggiungilo subito:

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

Passaggio 3: fornisci le immagini al rilevatore

Il rilevamento e la classificazione degli oggetti prevedono l'elaborazione asincrona:

  • Invii un'immagine al rilevatore (tramite process()).
  • Il rilevatore si impegna molto.
  • Il rilevatore ti segnala il risultato tramite un callback.

Il seguente codice fa esattamente questo (copialo e aggiungilo al codice esistente all'interno di 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())
   }

Al termine, il rilevatore ti invia una notifica con:

  • Il numero totale di oggetti rilevati. Ogni oggetto rilevato viene descritto con:
  • trackingId: un numero intero che utilizzi per monitorare i frame incrociati (NON utilizzato in questo codelab).
  • boundingBox: il riquadro di delimitazione dell'oggetto.
  • labels: un elenco di etichette per l'oggetto rilevato (solo quando la classificazione è abilitata):
  • index (recupera l'indice di questa etichetta)
  • text (recupera il testo di questa etichetta, ad esempio "Articoli di moda", "Cibo", "Articoli per la casa", "Luogo", "Pianta")
  • confidence ( un numero in virgola mobile compreso tra 0,0 e 1,0 con 1,0 indica il 100%)

Probabilmente avrai notato che il codice esegue un tipo di elaborazione Printf per il risultato rilevato con debugPrint().

Aggiungilo a MainActivity corso:

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}")
       }
   }
}

Ora puoi accettare immagini per il rilevamento.

Eseguiamo il codelab facendo clic su Esegui ( execute.png) nella barra degli strumenti di Android Studio. Prova a selezionare un'immagine preimpostata o scatta una foto, quindi guarda la finestra logcat( 16bd6ea224cf8cf1.png) all'interno dell'IDE.

Il risultato dovrebbe essere simile a questo:

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

...il che significa che il rilevatore ha rilevato 3 oggetti:

  • Le categorie sono Cibo e Casa bene.
  • Non è stata restituita nessuna categoria per il 2° posto perché è una classe sconosciuta.
  • Nessun trackingId (perché questa è la modalità di rilevamento di immagine singola).
  • La posizione all'interno del rettangolo boundingBox (ad es. (481, 2021) - (2426, 3376))
  • Il rilevatore è abbastanza sicuro che il primo sia un cibo (90% di confidenza, era un'insalata).

Tecnicamente è tutto ciò che serve per far funzionare il rilevamento degli oggetti del kit ML: al momento è tutto. Complimenti!

Dal punto di vista dell'interfaccia utente, sei ancora nella fase di inizio, ma puoi utilizzare i risultati rilevati nell'interfaccia utente, ad esempio disegnando il riquadro di delimitazione per creare un'esperienza migliore: andiamo al passaggio successivo: ultima elaborazione dei risultati rilevati.

6. Post-elaborazione dei risultati del rilevamento

Nei passaggi precedenti, hai stampato il risultato rilevato in logcat: è semplice e veloce.

In questa sezione, utilizzerai il risultato nell'immagine:

  • disegna il riquadro di delimitazione sull'immagine
  • traccia il nome e l'affidabilità della categoria all'interno del riquadro di delimitazione

Informazioni sulle utilità di visualizzazione

All'interno del codelab è presente un codice boilerplate, che ti aiuta a visualizzare il risultato del rilevamento. Sfrutta queste utilità per semplificare il nostro codice di visualizzazione:

  • data class BoxWithText(val box: Rect, val text: String) Si tratta di una classe di dati in cui archiviare un risultato del rilevamento di oggetti per la visualizzazione. box è il riquadro di delimitazione in cui l'oggetto viene individuato, mentre text è la stringa del risultato del rilevamento da visualizzare insieme al riquadro di delimitazione dell'oggetto.
  • fun drawDetectionResult(bitmap: Bitmap, detectionResults: List<BoxWithText>): Bitmap Questo metodo traccia i risultati del rilevamento degli oggetti in detectionResults nell'input bitmap e restituisce la copia modificata.

Ecco un esempio di output del metodo di utilità drawDetectionResult:

58c6f1d4ddb00dfa.png

Visualizzare il risultato del rilevamento di ML Kit

Utilizza le utilità di visualizzazione per disegnare il risultato del rilevamento degli oggetti ML Kit sull'immagine di input.

Vai nella posizione in cui chiami debugPrint() e aggiungi il seguente snippet di codice sotto:

// 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)
}
  • Inizierai analizzando il valore DetectedObject dell'ML Kit e creando un elenco di oggetti BoxWithText per visualizzare il risultato della visualizzazione.
  • Quindi, con il metodo dell'utilità drawDetectionResult, tracci il risultato del rilevamento sopra l'immagine di input e lo mostri sullo schermo.

Esegui

Ora fai clic su Esegui ( execute.png) nella barra degli strumenti di Android Studio.

Una volta caricata l'app, premi il pulsante con l'icona della fotocamera, inquadra con la fotocamera un oggetto, scatta una foto, accetta la foto (nell'app Fotocamera) oppure tocca facilmente le immagini preimpostate. Dovresti vedere i risultati del rilevamento. premi di nuovo il pulsante o seleziona un'altra immagine da ripetere un paio di volte per provare l'ultimo ML Kit ODT.

a03109cb30d5014d.png

7. Complimenti!

Hai utilizzato ML Kit per aggiungere funzionalità di rilevamento di oggetti alla tua app:

  • 3 passaggi con 3 API
  • Crea immagine di input
  • Crea rilevatore
  • Invia immagine al rilevatore

Questo è tutto ciò che ti serve per renderlo operativo.

Man mano che procedi, potresti voler migliorare il modello: come puoi vedere che il modello predefinito può riconoscere solo cinque categorie, il modello non conosce nemmeno coltello, forchetta e bottiglia. Dai un'occhiata all'altro codelab nel nostro percorso di apprendimento Machine Learning - Object Detection sul dispositivo per scoprire come addestrare un modello personalizzato.

Argomenti trattati

  • Come aggiungere il rilevamento e il monitoraggio degli oggetti ML Kit alla tua app per Android
  • Come utilizzare il rilevamento e il monitoraggio degli oggetti on-device in ML Kit per rilevare oggetti nelle immagini

Passaggi successivi

  • Esplora di più con ML Kit ODT con più immagini e video in diretta per sperimentare il rilevamento e accuratezza e prestazioni della classificazione
  • Consulta il percorso di apprendimento Rilevamento di oggetti on-device Machine Learning - per scoprire come addestrare un modello personalizzato
  • Applica il protocollo ML Kit ODT nella tua app per Android

Scopri di più