Rileva oggetti nelle immagini con ML Kit: Android

1. Prima di iniziare

ML Kit è un SDK mobile che porta le competenze di machine learning on-device di Google alle app per Android e iOS. Puoi utilizzare le API Vision e Natural Language, efficaci ma semplici da usare, per risolvere le sfide comuni nelle tue app o creare nuove esperienze utente. Tutti sono basati sui migliori modelli di ML di Google e ti vengono offerti senza costi.

Le API di ML Kit vengono eseguite tutte sul dispositivo, consentendo casi d'uso in tempo reale, ad esempio quando vuoi elaborare uno stream live 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 alla tua app Android esistente. Tieni presente che questo codelab utilizza alcune scorciatoie per evidenziare l'utilizzo di ODT di ML Kit.

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 gli 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 per il rilevamento e il monitoraggio degli oggetti

Che cosa ti serve

  • Una versione recente di Android Studio (v4.1.2 o successive)
  • L'emulatore Android Studio o un dispositivo Android fisico
  • Il codice di esempio
  • 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 link seguente per scaricare tutto il codice di questo codelab:

Estrai il file ZIP scaricato. Verrà scompattata una cartella principale (mlkit-android-main) con tutte le risorse necessarie. Per questo codelab, ti serviranno solo le origini nella sottodirectory object-detection.

La sottodirectory object-detection nel repository mlkit-android contiene due directory:

  • android_studio_folder.pngstarter: il codice di avvio su cui basarti per questo codelab.
  • android_studio_folder.pngfinal: codice completo per l'app di esempio completata.

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

Importa l'app in Android Studio

Iniziamo importando l'app di avvio in Android Studio.

Apri Android Studio, seleziona Importa progetto (Gradle, Eclipse ADT e così via) 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 di ML Kit

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

build.gradle

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

Sincronizzare il 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 Sincronizza progetto con i file Gradle ( b451ab2d04d835f9.png) dalla barra degli strumenti di Android Studio.

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

4. Esegui l'app di avvio

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

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

Eseguire ed esplorare l'app

L'app dovrebbe avviarsi sul tuo dispositivo Android. Contiene del codice boilerplate che ti consente di acquisire una foto o selezionare un'immagine preimpostata e di inviarla 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, in basso è presente un pulsante ( c6d965d639c3646.png) per:

  • Apri l'app Fotocamera integrata nel dispositivo/nell'emulatore
  • scattare una foto nell'app Fotocamera
  • Riceve l'immagine acquisita nell'app di avvio
  • visualizzare l'immagine

Prova il pulsante Scatta foto, segui le istruzioni per scattare una foto, accetta la foto e osservala all'interno dell'app di avvio.

Ripeti l'operazione alcune volte per vedere come funziona:

9ec541980dbe2d31.png 8312dde41425ba4b.png fa8492bfc1914ff0.png

In secondo luogo, puoi scegliere tra tre immagini predefinite. Puoi utilizzare queste immagini in un secondo momento per testare il codice di rilevamento degli oggetti se esegui l'emulatore Android.

Seleziona un'immagine tra le tre immagini predefinite. Verifica che l'immagine venga visualizzata nella visualizzazione più grande:

1dd41b3ec978f1d9.png

5. Aggiungere il rilevamento di oggetti sul dispositivo

In questo passaggio aggiungerai all'app iniziale la funzionalità di rilevamento degli oggetti nelle immagini. Come hai visto nel passaggio precedente, l'app iniziale contiene codice boilerplate per scattare foto con l'app Fotocamera sul dispositivo. L'app contiene anche tre immagini predefinite su cui puoi provare il rilevamento degli oggetti se esegui il codelab su un emulatore Android.

Dopo aver selezionato un'immagine, dalle immagini predefinite o scattando 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 eseguire il rilevamento degli oggetti.

Configurare ed eseguire il rilevamento di oggetti on-device su un'immagine

Per configurare ML Kit ODT sono sufficienti tre semplici passaggi con tre API:

  • Prepara un'immagine: InputImage
  • Crea un oggetto detector: ObjectDetection.getClient(options)
  • Collega i due oggetti sopra: process(image)

Puoi ottenere questi risultati 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. Passa ai passaggi che seguono per implementare ML Kit ODT. Durante la procedura, 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 InputImage

ML Kit fornisce un'API semplice per creare un InputImage da un Bitmap. Dopodiché puoi fornire un InputImage alle 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 pattern di progettazione del costruttore. Trasmetti la configurazione al generatore e acquisisci un rilevatore. Sono disponibili tre opzioni di configurazione (in questo codelab vengono utilizzate le opzioni in grassetto):

  • modalità di rilevamento (immagine singola o stream)
  • modalità di rilevamento (singolo o più rivelamenti di oggetti).
  • modalità di classificazione (attiva o disattivata)

Questo codelab è dedicato al rilevamento e alla classificazione di più oggetti in un'unica immagine. Aggiungilo ora:

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

Passaggio 3: invia le immagini al rilevatore

Il rilevamento e la classificazione degli oggetti sono elaborazioni asincrone:

  • Invii un'immagine al rilevatore (tramite process()).
  • Il rilevatore lavora sodo.
  • Il Detector ti restituisce il risultato tramite un callback.

Il codice seguente fa proprio questo (copia e accoda il 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 è descritto da:
  • trackingId: un numero intero utilizzato per monitorarlo tra i frame (NON utilizzato in questo codelab).
  • boundingBox: il riquadro di delimitazione dell'oggetto.
  • labels: un elenco di etichette per l'oggetto rilevato (solo se la classificazione è attivata):
  • index (recupera l'indice di questa etichetta)
  • text (ottieni il testo di questa etichetta, ad esempio "Prodotti di moda", "Cibo", "Prodotti per la casa", "Luogo", "Pianta")
  • confidence ( un valore float compreso tra 0,0 e 1,0, dove 1,0 indica il 100%)

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

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

Ora puoi accettare le immagini per il rilevamento.

Esegui 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 controlla la finestra logcat( 16bd6ea224cf8cf1.png) all'interno dell'IDE.

Dovresti visualizzare un messaggio simile al seguente:

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 visto 3 oggetti:

  • Le categorie sono Cibo e Prodotti per la casa.
  • Non viene restituita alcuna categoria per il secondo perché si tratta di un corso sconosciuto.
  • No trackingId (perché questa è la modalità di rilevamento di una singola immagine).
  • La posizione all'interno del rettangolo boundingBox (ad es. (481, 2021) - (2426, 3376))
  • Il rilevatore è abbastanza sicuro che la prima sia un'immagine di cibo (90% di confidenza: era insalata).

Tecnicamente, è tutto ciò che ti serve per far funzionare il rilevamento di oggetti di ML Kit: al momento hai tutto. Complimenti!

Per quanto riguarda l'interfaccia utente, sei ancora nella fase in cui hai iniziato, ma potresti utilizzare i risultati rilevati nell'interfaccia utente, ad esempio disegnare la casella delimitante per creare un'esperienza migliore: passiamo al passaggio successivo: il post-trattamento 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
  • disegna il nome della categoria e il livello di confidenza all'interno del riquadro delimitante

Informazioni sulle utilità di visualizzazione

All'interno del codelab è presente del codice boilerplate per aiutarti a visualizzare il risultato del rilevamento. Utilizza queste utilità per semplificare il codice di visualizzazione:

  • data class BoxWithText(val box: Rect, val text: String) Questa è una classe di dati per archiviare un risultato del rilevamento degli oggetti per la visualizzazione. box è il riquadro di delimitazione in cui si trova l'oggetto e 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 disegna i risultati del rilevamento degli oggetti in detectionResults sull'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 di ML Kit sopra l'immagine di input.

Vai alla chiamata di 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)
}
  • Inizia analizzando DetectedObject di ML Kit e creando un elenco di oggetti BoxWithText per visualizzare il risultato della visualizzazione.
  • Poi, utilizzando il metodo di utilità drawDetectionResult, disegni 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, punta la fotocamera verso un oggetto, scatta una foto, accetta la foto (nell'app Fotocamera) o tocca facilmente qualsiasi immagine preimpostata. Dovresti vedere i risultati del rilevamento. Premi di nuovo il pulsante o seleziona un'altra immagine per ripetere l'operazione un paio di volte e provare l'ultima versione di 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

È tutto ciò che ti serve per iniziare a utilizzare il servizio.

Man mano che procedi, potresti voler migliorare il modello: come puoi vedere, il modello predefinito può riconoscere solo cinque categorie e non conosce nemmeno coltello, forchetta e bottiglia. Consulta l'altro codelab nel nostro percorso di apprendimento sul machine learning on-device - Rilevamento di oggetti per scoprire come addestrare un modello personalizzato.

Argomenti trattati

  • Come aggiungere il rilevamento e il monitoraggio degli oggetti di ML Kit alla tua app per Android
  • Come utilizzare il rilevamento e il monitoraggio degli oggetti sul dispositivo in ML Kit per rilevare gli oggetti nelle immagini

Passaggi successivi

  • Scopri di più con ML Kit ODT con più immagini e video in diretta per sperimentare l'accuratezza e il rendimento del rilevamento e della classificazione
  • Consulta la sezione Machine learning on-device - Percorso di apprendimento del rilevamento di oggetti per scoprire come addestrare un modello personalizzato
  • Applicare ODT di ML Kit nella tua app per Android

Scopri di più