ML Kit e riconoscimento delle immagini

In questa lezione esploreremo dettagliatamente l'impiego del ML Kit di Google per la creazione di un'applicazione dedicata al riconoscimento di immagini, appositamente progettata per piattaforma Android. ML Kit, essendo uno dei framework più avanzati nel campo dell'intelligenza artificiale mobile, offre agli sviluppatori una vasta gamma di funzionalità per integrare la capacità di analisi e interpretazione delle immagini all'interno delle applicazioni Android. Esamineremo i passaggi fondamentali per lo sviluppo della suddetta applicazione, inclusi i prerequisiti necessari e il codice di esempio per illustrare il processo di riconoscimento di immagini in dettaglio.

Riconoscere gli oggetti in un'immagine con ML Kit

Come già mostrato nella lezione precedente, anche in questo caso dobbiamo prima di tutto integrare correttamente le dipendenze di ML Kit all'interno della nostra applicazione Android. Quindi, aggiungiamo le seguenti dipendenze nel file build.gradle:

dependencies {
    // Dipendenza per il riconoscimento di immagini
    implementation 'com.google.firebase:firebase-ml-vision-image-label-model:24.1.0'
}

Come possiamo vedere dal codice, quello che stiamo facendo è adoperare la dipendenza Firebase per ML Kit. Firebase è una piattaforma di sviluppo di applicazioni mobile e web sviluppata da Google che offre una vasta gamma di strumenti e servizi che consentono agli sviluppatori di creare, migliorare e gestire le proprie applicazioni in modo efficiente e scalabile. ML Kit offre due modalità di utilizzo: on-device e Cloud.

• On-device (ovvero senza Firebase): ML Kit viene scaricato direttamente sul dispositivo dell'utente e il riconoscimento delle immagini avviene localmente, senza richiedere alcuna connessione a Internet. Questa modalità è ottima per applicazioni che richiedono prestazioni veloci e che operano principalmente offline. In questa modalità non è necessario utilizzare Firebase.
• Cloud (con Firebase): in questa modalità ML Kit è ospitato su Firebase e il riconoscimento delle immagini avviene sul Cloud. Questo può essere utile per applicazioni che richiedono un'ampia gamma di funzionalità di Machine Learning o che necessitano di aggiornamenti frequenti dei modelli. Tuttavia, l'utilizzo del Cloud richiede una connessione Internet attiva e l'integrazione con Firebase.

ML Kit e integrazioni

Per scopo didattico abbiamo deciso di adoperare questa modalità anche per poter avere contezza della possibile alternativa di integrazione di ML Kit. Adesso, inseriamo all'interno del metodo onCreate() del file MainActivity.java del progetto Android, il seguente codice:

import android.content.Intent;
import android.graphics.Bitmap;
import android.net.Uri;
import android.os.Bundle;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import com.google.firebase.ml.vision.common.FirebaseVisionImage;
import java.io.IOException;
public class MainActivity extends AppCompatActivity {
    private static final int PICK_IMAGE_REQUEST = 2;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        // Avvia l'intent per selezionare un'immagine dalla galleria
        Intent pickImageIntent = new Intent(Intent.ACTION_PICK);
        pickImageIntent.setType("image/*");
        startActivityForResult(pickImageIntent, PICK_IMAGE_REQUEST);
    }
    // Metodo per ricevere il risultato dell'intent di selezione dell'immagine dalla galleria
    @Override
    protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        if (requestCode == PICK_IMAGE_REQUEST && resultCode == RESULT_OK && data != null && data.getData() != null) {
            Uri imageUri = data.getData();
            // Converiamo l'URI dell'immagine in un Bitmap
            try {
                Bitmap bitmap = MediaStore.Images.Media.getBitmap(getContentResolver(), imageUri);
                FirebaseVisionImage image = FirebaseVisionImage.fromBitmap(bitmap);
            // Ora possiamo utilizzare l'oggetto 'image' per eseguire il riconoscimento di immagini con ML Kit
                // Ad esempio, potremmo passare 'image' al riconoscitore di etichette FirebaseVisionImageLabeler
                // e gestire i risultati del riconoscimento.
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

In questo codice, dopo aver ottenuto la Bitmap dell'immagine selezionata, viene creato un oggetto FirebaseVisionImage utilizzando il metodo FirebaseVisionImage.fromBitmap(bitmap). Questo oggetto FirebaseVisionImage può adesso essere utilizzato per eseguire il riconoscimento delle immagini con ML Kit, come illustrato nei commenti nel codice.

L'oggetto FirebaseVisionImageLabeler

In questa parte del codice, dopo aver creato l'oggetto FirebaseVisionImage dall'immagine selezionata, viene creato un riconoscitore di etichette FirebaseVisionImageLabeler tramite FirebaseVision.getInstance().getOnDevideImageLabeler(). Successivamente, l'immagine viene processata utilizzando il riconoscitore di etichette tramite il metodo processImage(image).

Infine, vengono gestiti i risultati del riconoscimento nell'onSuccessListener e gli eventuali errori nell'onFailureListener.

FirebaseVisionImageLabeler labeler = FirebaseVision.getInstance()
                    .getOnDeviceImageLabeler();
            labeler.processImage(image)
                    .addOnSuccessListener(labels -> {
                        // gestiamo i risultati del riconoscimento
                        for (FirebaseVisionImageLabel label : labels) {
                            String text = label.getText();
                            String entityId = label.getEntityId();
                            float confidence = label.getConfidence();
                            // gestiamo le etichette rilevate
                        }
                    })
                    .addOnFailureListener(e -> {
                        // gestiamo eventuali errori
                    });

Quando FirebaseVisionImageLabeler ha terminato il processo di analisi dell'immagine e ha individuato gli oggetti presenti, restituisce una lista di etichette (labels) che descrivono gli oggetti rilevati, insieme alla relativa confidenza.

Gestione delle etichette

La gestione di queste etichette può includere diverse attività, tra cui:

• visualizzazione delle etichette: è possibile visualizzare le etichette rilevate nell'interfaccia dell'applicazione per informare l'utente sui contenuti dell'immagine. Ad esempio, potremmo mostrare una lista di etichette o aggiungere sovrapposizioni grafiche sull'immagine originale per evidenziare gli oggetti individuati.
• Elaborazione delle etichette: possiamo elaborare le etichette rilevate in base alle esigenze dell'applicazione. Ad esempio, potremmo filtrare le etichette in base alla loro confidenza o eseguire azioni specifiche in base agli oggetti identificati.
• Feedback all'utente: potremmo utilizzare le etichette rilevate per fornire feedback all'utente sull'accuratezza del riconoscimento. Ad esempio, far visualizzare un messaggio di conferma quando viene identificato un oggetto con elevata confidenza o chiedere all'utente di confermare o correggere le etichette rilevate.

Sulla base del codice riportato sopra, se volessimo mostrare le etichette sopra gli oggetti individuati potremmo pensare di creare un nuovo metodo showLabelsToUser(String labelsText) che prende in input il testo delle etichette rilevate e lo mostra all'utente nell'interfaccia utente dell'applicazione. Le etichette vengono visualizzate in un AlertDialog, anche se potremmo mostrarle in un qualsiasi altro componente dell'interfaccia utente, come un TextView o una RecyclerView.

labeler.processImage(image)
        .addOnSuccessListener(labels -> {
            // gestiamo le etichette rilevate
            StringBuilder labelsText = new StringBuilder();
            for (FirebaseVisionImageLabel label : labels) {
                String text = label.getText();
                float confidence = label.getConfidence();
                labelsText.append(text).append(": ").append(confidence).append("\n");
            }
            // Mostriamo le etichette rilevate all'utente nell'interfaccia utente dell'applicazione
            showLabelsToUser(labelsText.toString());
        })
        .addOnFailureListener(e -> {
            // Gestiamo eventuali errori
        });

Il codice della funzione showLabelsToUser:

private void showLabelsToUser(String labelsText) {
    // Possiamo visualizzare le etichette rilevate in un TextView o in qualsiasi altro componente dell'interfaccia utente
    // In questo esempio, mostriamo le etichette in un AlertDialog
    AlertDialog.Builder builder = new AlertDialog.Builder(this);
    builder.setTitle("Etichette Rilevate");
    builder.setMessage(labelsText);
    builder.setPositiveButton("OK", (dialog, which) -> {
        // Azione da eseguire quando l'utente preme il pulsante OK
        dialog.dismiss(); // Chiudiamo il dialog
    });
    AlertDialog dialog = builder.create();
    dialog.show();
}

Conclusioni

Come abbiamo visto l'integrazione di Firebase ML Kit ha reso relativamente semplice l'implementazione del riconoscimento di immagini nell'applicazione Android, consentendo di arricchire l'esperienza dell'utente e aggiungere funzionalità avanzate senza la necessità di conoscenze approfondite di Machine Learning.