Etichetta le immagini con Firebase ML su Android

Puoi utilizzare Firebase ML per etichettare gli oggetti riconosciuti in un'immagine. Consulta la panoramica per informazioni sulle funzionalità di questa API.

Prima di iniziare

  1. Se non l'hai già fatto, aggiungi Firebase al tuo progetto Android.
  2. Nel file Gradle del modulo (a livello di app) (di solito <project>/<app-module>/build.gradle.kts o <project>/<app-module>/build.gradle), aggiungi la dipendenza per la libreria Firebase ML Vision per Android. Ti consigliamo di utilizzare Firebase Android BoM per controllare il controllo delle versioni delle librerie. 
    dependencies {
    // Import the BoM for the Firebase platform
    implementation(platform("com.google.firebase:firebase-bom:33.3.0"))

    // Add the dependency for the Firebase ML Vision library
    // When using the BoM, you don't specify versions in Firebase library dependencies
    implementation 'com.google.firebase:firebase-ml-vision'
}

    Se utilizzi Firebase Android BoM, la tua app utilizzerà sempre versioni compatibili delle librerie Firebase Android.

    (alternativa) Aggiungi dipendenze della libreria Firebase senza utilizzare il BoM

    Se scegli di non utilizzare Firebase BoM, devi specificare ogni versione della libreria Firebase nella relativa riga di dipendenza.

    Tieni presente che se utilizzi più librerie Firebase nella tua app, ti consigliamo consiglia di utilizzare BoM per gestire le versioni della libreria, in modo da garantire che tutte le versioni siano compatibili. 

    dependencies {
    // Add the dependency for the Firebase ML Vision library
    // When NOT using the BoM, you must specify versions in Firebase library dependencies
    implementation 'com.google.firebase:firebase-ml-vision:24.1.0'
}
         Cerchi un modulo della libreria specifico per Kotlin? A partire da Ottobre 2023 (Firebase BoM 32.5.0), gli sviluppatori Kotlin e Java possono dipendono dal modulo principale della libreria (per i dettagli, consulta Domande frequenti su questa iniziativa).

  3. Se non hai ancora attivato le API basate su cloud per il tuo progetto, fallo subito:

    1. Apri l'app Firebase ML API della console Firebase.

    2. Se non hai già eseguito l'upgrade del progetto al piano tariffario Blaze, fai clic su Per farlo, esegui l'upgrade. Ti verrà chiesto di eseguire l'upgrade solo se non è incluso nel piano Blaze.)

      Solo i progetti a livello di Blaze possono utilizzare le API basate su cloud.

    3. Se le API basate su cloud non sono già abilitate, fai clic su Abilita basate su cloud per le API.

Ora puoi etichettare le immagini.

1. Prepara l'immagine di input

Crea un oggetto FirebaseVisionImage dalla tua immagine. Lo strumento di etichettatura delle immagini funziona più velocemente quando usi un Bitmap o, se usi lo camera2 dell'API, media.Image in formato JPEG, consigliate quando possibile.

  • Per creare un oggetto FirebaseVisionImage da un oggetto media.Image, ad esempio quando acquisisci un'immagine dalla fotocamera di un dispositivo, passa l'oggetto media.Image e la rotazione dell'immagine a FirebaseVisionImage.fromMediaImage().

    Se utilizzi la libreria CameraX, le classi OnImageCapturedListener e ImageAnalysis.Analyzer calcolano il valore di rotazione per te, quindi devi solo convertire la rotazione in una delle costanti ROTATION_ di Firebase ML prima di chiamare FirebaseVisionImage.fromMediaImage():

    Kotlin+KTX

    private class YourImageAnalyzer : ImageAnalysis.Analyzer {
    private fun degreesToFirebaseRotation(degrees: Int): Int = when(degrees) {
        0 -> FirebaseVisionImageMetadata.ROTATION_0
        90 -> FirebaseVisionImageMetadata.ROTATION_90
        180 -> FirebaseVisionImageMetadata.ROTATION_180
        270 -> FirebaseVisionImageMetadata.ROTATION_270
        else -> throw Exception("Rotation must be 0, 90, 180, or 270.")
    }

    override fun analyze(imageProxy: ImageProxy?, degrees: Int) {
        val mediaImage = imageProxy?.image
        val imageRotation = degreesToFirebaseRotation(degrees)
        if (mediaImage != null) {
            val image = FirebaseVisionImage.fromMediaImage(mediaImage, imageRotation)
            // Pass image to an ML Vision API
            // ...
        }
    }
}

    Java

    private class YourAnalyzer implements ImageAnalysis.Analyzer {

    private int degreesToFirebaseRotation(int degrees) {
        switch (degrees) {
            case 0:
                return FirebaseVisionImageMetadata.ROTATION_0;
            case 90:
                return FirebaseVisionImageMetadata.ROTATION_90;
            case 180:
                return FirebaseVisionImageMetadata.ROTATION_180;
            case 270:
                return FirebaseVisionImageMetadata.ROTATION_270;
            default:
                throw new IllegalArgumentException(
                        "Rotation must be 0, 90, 180, or 270.");
        }
    }

    @Override
    public void analyze(ImageProxy imageProxy, int degrees) {
        if (imageProxy == null || imageProxy.getImage() == null) {
            return;
        }
        Image mediaImage = imageProxy.getImage();
        int rotation = degreesToFirebaseRotation(degrees);
        FirebaseVisionImage image =
                FirebaseVisionImage.fromMediaImage(mediaImage, rotation);
        // Pass image to an ML Vision API
        // ...
    }
}

    Se non utilizzi una raccolta di videocamere che ti fornisce la rotazione dell'immagine, può calcolarla in base alla rotazione del dispositivo e all'orientamento della fotocamera nel dispositivo:

    Kotlin+KTX

    private val ORIENTATIONS = SparseIntArray()

init {
    ORIENTATIONS.append(Surface.ROTATION_0, 90)
    ORIENTATIONS.append(Surface.ROTATION_90, 0)
    ORIENTATIONS.append(Surface.ROTATION_180, 270)
    ORIENTATIONS.append(Surface.ROTATION_270, 180)
}
/**
 * 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, context: Context): 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)

    // On most devices, the sensor orientation is 90 degrees, but for some
    // devices it is 270 degrees. For devices with a sensor orientation of
    // 270, rotate the image an additional 180 ((270 + 270) % 360) degrees.
    val cameraManager = context.getSystemService(CAMERA_SERVICE) as CameraManager
    val sensorOrientation = cameraManager
        .getCameraCharacteristics(cameraId)
        .get(CameraCharacteristics.SENSOR_ORIENTATION)!!
    rotationCompensation = (rotationCompensation + sensorOrientation + 270) % 360

    // Return the corresponding FirebaseVisionImageMetadata rotation value.
    val result: Int
    when (rotationCompensation) {
        0 -> result = FirebaseVisionImageMetadata.ROTATION_0
        90 -> result = FirebaseVisionImageMetadata.ROTATION_90
        180 -> result = FirebaseVisionImageMetadata.ROTATION_180
        270 -> result = FirebaseVisionImageMetadata.ROTATION_270
        else -> {
            result = FirebaseVisionImageMetadata.ROTATION_0
            Log.e(TAG, "Bad rotation value: $rotationCompensation")
        }
    }
    return result
}
    VisionImage.kt

    Java

    private static final SparseIntArray ORIENTATIONS = new SparseIntArray();
static {
    ORIENTATIONS.append(Surface.ROTATION_0, 90);
    ORIENTATIONS.append(Surface.ROTATION_90, 0);
    ORIENTATIONS.append(Surface.ROTATION_180, 270);
    ORIENTATIONS.append(Surface.ROTATION_270, 180);
}

/**
 * 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, Context context)
        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);

    // On most devices, the sensor orientation is 90 degrees, but for some
    // devices it is 270 degrees. For devices with a sensor orientation of
    // 270, rotate the image an additional 180 ((270 + 270) % 360) degrees.
    CameraManager cameraManager = (CameraManager) context.getSystemService(CAMERA_SERVICE);
    int sensorOrientation = cameraManager
            .getCameraCharacteristics(cameraId)
            .get(CameraCharacteristics.SENSOR_ORIENTATION);
    rotationCompensation = (rotationCompensation + sensorOrientation + 270) % 360;

    // Return the corresponding FirebaseVisionImageMetadata rotation value.
    int result;
    switch (rotationCompensation) {
        case 0:
            result = FirebaseVisionImageMetadata.ROTATION_0;
            break;
        case 90:
            result = FirebaseVisionImageMetadata.ROTATION_90;
            break;
        case 180:
            result = FirebaseVisionImageMetadata.ROTATION_180;
            break;
        case 270:
            result = FirebaseVisionImageMetadata.ROTATION_270;
            break;
        default:
            result = FirebaseVisionImageMetadata.ROTATION_0;
            Log.e(TAG, "Bad rotation value: " + rotationCompensation);
    }
    return result;
}
    VisionImage.java

    Poi, passa l'oggetto media.Image e il valore di rotazione a FirebaseVisionImage.fromMediaImage():

    Kotlin+KTX

    val image = FirebaseVisionImage.fromMediaImage(mediaImage, rotation)
    VisionImage.kt

    Java

    FirebaseVisionImage image = FirebaseVisionImage.fromMediaImage(mediaImage, rotation);
    VisionImage.java
  • Per creare un oggetto FirebaseVisionImage da un URI file, passa il contesto dell'app e l'URI file a FirebaseVisionImage.fromFilePath(). Questa opzione è utile quando utilizzi un'intenzione ACTION_GET_CONTENT per chiedere all'utente di selezionare un'immagine dalla sua app Galleria.

    Kotlin+KTX

    val image: FirebaseVisionImage
try {
    image = FirebaseVisionImage.fromFilePath(context, uri)
} catch (e: IOException) {
    e.printStackTrace()
}
    VisionImage.kt

    Java

    FirebaseVisionImage image;
try {
    image = FirebaseVisionImage.fromFilePath(context, uri);
} catch (IOException e) {
    e.printStackTrace();
}
    VisionImage.java
  • Per creare un oggetto FirebaseVisionImage da un ByteBuffer o un array di byte, calcola prima l'immagine rotazione come descritto sopra per l'input media.Image.

    Quindi, crea un oggetto FirebaseVisionImageMetadata che contiene l'altezza, la larghezza, il formato di codifica del colore, e la rotazione:

    Kotlin+KTX

    val metadata = FirebaseVisionImageMetadata.Builder()
    .setWidth(480) // 480x360 is typically sufficient for
    .setHeight(360) // image recognition
    .setFormat(FirebaseVisionImageMetadata.IMAGE_FORMAT_NV21)
    .setRotation(rotation)
    .build()
    VisionImage.kt

    Java

    FirebaseVisionImageMetadata metadata = new FirebaseVisionImageMetadata.Builder()
        .setWidth(480)   // 480x360 is typically sufficient for
        .setHeight(360)  // image recognition
        .setFormat(FirebaseVisionImageMetadata.IMAGE_FORMAT_NV21)
        .setRotation(rotation)
        .build();
    VisionImage.java

    Utilizza il buffer o l'array e l'oggetto metadati per creare un Oggetto FirebaseVisionImage:

    Kotlin+KTX

    val image = FirebaseVisionImage.fromByteBuffer(buffer, metadata)
// Or: val image = FirebaseVisionImage.fromByteArray(byteArray, metadata)
    VisionImage.kt

    Java

    FirebaseVisionImage image = FirebaseVisionImage.fromByteBuffer(buffer, metadata);
// Or: FirebaseVisionImage image = FirebaseVisionImage.fromByteArray(byteArray, metadata);
    VisionImage.java
  • Per creare un oggetto FirebaseVisionImage da un oggetto Bitmap:

    Kotlin+KTX

    val image = FirebaseVisionImage.fromBitmap(bitmap)
    VisionImage.kt

    Java

    FirebaseVisionImage image = FirebaseVisionImage.fromBitmap(bitmap);
    VisionImage.java
    L'immagine rappresentata dall'oggetto Bitmap deve essere in verticale, senza alcuna rotazione aggiuntiva.

2. Configura ed esegui l'etichettatore delle immagini

Per etichettare gli oggetti in un'immagine, passa l'oggetto FirebaseVisionImage all'elemento Metodo processImage di FirebaseVisionImageLabeler.

  1. Per prima cosa, ottieni un'istanza FirebaseVisionImageLabeler

    Kotlin+KTX 

    val labeler = FirebaseVision.getInstance().getCloudImageLabeler()

// Or, to set the minimum confidence required:
// val options = FirebaseVisionCloudImageLabelerOptions.Builder()
//     .setConfidenceThreshold(0.7f)
//     .build()
// val labeler = FirebaseVision.getInstance().getCloudImageLabeler(options)

    Java 

    FirebaseVisionImageLabeler labeler = FirebaseVision.getInstance()
    .getCloudImageLabeler();

// Or, to set the minimum confidence required:
// FirebaseVisionCloudImageLabelerOptions options =
//     new FirebaseVisionCloudImageLabelerOptions.Builder()
//         .setConfidenceThreshold(0.7f)
//         .build();
// FirebaseVisionImageLabeler labeler = FirebaseVision.getInstance()
//     .getCloudImageLabeler(options);

  2. Quindi, passa l'immagine al metodo processImage():

    Kotlin+KTX 

    labeler.processImage(image)
    .addOnSuccessListener { labels ->
      // Task completed successfully
      // ...
    }
    .addOnFailureListener { e ->
      // Task failed with an exception
      // ...
    }

    Java 

    labeler.processImage(image)
    .addOnSuccessListener(new OnSuccessListener<List<FirebaseVisionImageLabel>>() {
      @Override
      public void onSuccess(List<FirebaseVisionImageLabel> labels) {
        // Task completed successfully
        // ...
      }
    })
    .addOnFailureListener(new OnFailureListener() {
      @Override
      public void onFailure(@NonNull Exception e) {
        // Task failed with an exception
        // ...
      }
    });

3. Ottieni informazioni sugli oggetti etichettati

Se l'operazione di etichettatura delle immagini ha esito positivo, viene visualizzato un elenco FirebaseVisionImageLabel oggetti verranno passati all'account ascoltatori di successo. Ogni oggetto FirebaseVisionImageLabel rappresenta un elemento etichettato nell'immagine. Per ogni etichetta, puoi visualizzare il relativo testo descrizione, è ID entità Knowledge Graph (se disponibile) e il punteggio di confidenza della corrispondenza. Ad esempio:

Kotlin+KTX 

for (label in labels) {
  val text = label.text
  val entityId = label.entityId
  val confidence = label.confidence
}

Java 

for (FirebaseVisionImageLabel label: labels) {
  String text = label.getText();
  String entityId = label.getEntityId();
  float confidence = label.getConfidence();
}

Passaggi successivi