Etichetta le immagini con Firebase ML su Android

Questa pagina descrive una versione precedente dell'etichettatura degli oggetti riconosciuti in un'immagine utilizzando l'SDK Firebase ML Vision deprecato. In alternativa, puoi chiamare le API Cloud Vision utilizzando Firebase Auth e le funzioni chiamabili per consentire solo agli utenti che hanno eseguito l'accesso alla tua app di accedere all'API.

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

L'utilizzo delle API Cloud Vision è soggetto al Contratto di licenza della piattaforma Google Cloud e ai Termini specifici dei servizi e viene fatturato di conseguenza. Per informazioni sulla fatturazione, consulta la pagina Prezzi.

Cerchi l'etichettatura delle immagini sul dispositivo? Prova la libreria ML Kit autonoma.

Prima di iniziare

1. Se non lo 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 la gestione delle versioni delle librerie.

   dependencies {
       // Import the BoM for the Firebase platform
       implementation(platform("com.google.firebase:firebase-bom:33.7.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'
   }

   Con Firebase Android BoM, la tua app utilizzerà sempre versioni compatibili delle librerie Firebase per Android.

   (Alternativa)  Aggiungi le dipendenze delle librerie Firebase senza utilizzare il file BoM

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

   Tieni presente che se nella tua app utilizzi più librerie Firebase, ti consigliamo vivamente di utilizzare BoM per gestire le versioni delle librerie, in modo da garantire la compatibilità di tutte le versioni.

   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), sia gli sviluppatori Kotlin che Java possono fare affidamento sul modulo della libreria principale (per maggiori dettagli, consulta le Domande frequenti su questa iniziativa).

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

   1. Apri la Firebase ML pagina API della console Firebase.

   2. Se non hai ancora eseguito l'upgrade del progetto al piano tariffario Blaze, fai clic su Esegui l'upgrade per farlo. Ti verrà chiesto di eseguire l'upgrade solo se il progetto non è nel piano Blaze.

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

   3. Se le API basate su cloud non sono già abilitate, fai clic su Abilita API basate su cloud.
   Prima di eseguire il deployment in produzione di un'app che utilizza un'API Cloud, devi eseguire alcuni passaggi aggiuntivi per prevenire e ridurre l'effetto dell'accesso non autorizzato all'API.

Ora puoi etichettare le immagini.

1. Prepara l'immagine di input

Crea un oggetto FirebaseVisionImage dalla tua immagine. L'etichettatore di immagini funziona più velocemente se utilizzi un Bitmap o, se utilizzi l'API camera2, un Bitmap in formato JPEG, che sono consigliati se possibile.media.Image

• 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

  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 libreria della fotocamera che ti fornisca la rotazione dell'immagine, puoi calcolarla dalla rotazione del dispositivo e dall'orientamento del sensore della fotocamera al suo interno:

  Kotlin

  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

  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 operazione è utile quando utilizzi un'intenzione ACTION_GET_CONTENT per chiedere all'utente di selezionare un'immagine dalla sua app Galleria.

  Kotlin

  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 da un array di byte, calcola prima la rotazione dell'immagine come descritto sopra per l'input media.Image.

  Quindi, crea un oggetto FirebaseVisionImageMetadata contenente l'altezza, la larghezza, il formato di codifica dei colori e la rotazione dell'immagine:

  Kotlin

  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 l'array o il buffer e l'oggetto dei metadati per creare un oggetto FirebaseVisionImage:

  Kotlin

  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

  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 di immagini

Per etichettare gli oggetti in un'immagine, passa l'oggetto FirebaseVisionImage al metodo processImage di FirebaseVisionImageLabeler.

1. Innanzitutto, ottieni un'istanza di FirebaseVisionImageLabeler.

   Kotlin

   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

   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. Ricevere informazioni sugli oggetti etichettati

Se l'operazione di etichettatura delle immagini va a buon fine, un elenco di oggetti FirebaseVisionImageLabel viene passato all'ascoltatore di eventi di successo. Ogni oggetto FirebaseVisionImageLabel rappresenta un elemento etichettato nell'immagine. Per ogni etichetta, puoi ottenere la descrizione del testo, l'ID entità Knowledge Graph (se disponibile) e il punteggio di affidabilità della corrispondenza. Ad esempio:

Kotlin

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

• Prima di eseguire il deployment in produzione di un'app che utilizza un'API Cloud, devi svolgere alcuni passaggi aggiuntivi per prevenire e ridurre l'effetto dell'accesso non autorizzato all'API.