Inserta objetos en imágenes con Imagen

Versión preliminar: El uso de los SDKs de Firebase AI Logic para acceder a los modelos de Imagen es una función en versión preliminar, lo que significa que no está sujeta a ningún ANS ni política de baja y podría cambiar de manera tal que deje de ser compatible con versiones anteriores.

La edición con Imagen solo se admite si usas Vertex AI Gemini API. Actualmente, solo se admite en apps para Android y Flutter. La compatibilidad con otras plataformas estará disponible más adelante este año.

En esta página, se describe cómo usar la reconstrucción con Imagen para insertar un objeto en una imagen con los SDKs de Firebase AI Logic.

El retoque es un tipo de edición basada en máscaras. Una máscara es una superposición digital que define el área específica que deseas editar.

Cómo funciona: Proporcionas una imagen original y una imagen enmascarada correspondiente (ya sea generada automáticamente o proporcionada por ti) que define una máscara sobre un área en la que deseas agregar contenido nuevo. También puedes proporcionar una instrucción de texto en la que se describa lo que quieres agregar. Luego, el modelo genera y agrega contenido nuevo dentro del área enmascarada.

Por ejemplo, puedes enmascarar una mesa y pedirle al modelo que agregue un jarrón con flores.

Ir al código de la máscara generada automáticamente Ir al código para proporcionar la máscara

Antes de comenzar

Solo está disponible cuando usas Vertex AI Gemini API como tu proveedor de la API.

Si aún no lo hiciste, completa la guía de introducción, en la que se describe cómo configurar tu proyecto de Firebase, conectar tu app a Firebase, agregar el SDK, inicializar el servicio de backend para el proveedor de la API que elijas y crear una instancia de ImagenModel.

En esta guía, se supone que usas los SDKs de Firebase AI Logic más recientes. Si aún usas los SDKs "Vertex AI in Firebase", consulta la guía de migración.

Modelos que admiten esta capacidad

Imagen ofrece edición de imágenes a través de su modelo capability:

• imagen-3.0-capability-001

Ten en cuenta que, para los modelos Imagen, no se admite la ubicación global.

Cómo insertar objetos con una máscara generada automáticamente

Antes de probar esta muestra, completa la sección Antes de comenzar de esta guía para configurar tu proyecto y tu app.

En el siguiente ejemplo, se muestra cómo usar el relleno para insertar contenido en una imagen con la generación automática de máscaras. Proporcionas la imagen original y una instrucción de texto, y Imagen detecta y crea automáticamente un área de máscara para modificar la imagen original.

Nota: Otra forma de generar automáticamente una máscara para objetos comunes en imágenes es usar ImagenSemanticMask (en lugar de ImagenBackgroundMask) y especificar el ID de clase de objeto para el objeto. Por ejemplo, puedes especificar un ID de clase de 67 y el modelo detectará cualquier tabla en la imagen y creará una máscara sobre ellas.

Swift

La edición de imágenes con modelos de Imagen no se admite en Swift. Vuelve a consultar más adelante este año.

Kotlin

Para insertar objetos con una máscara generada automáticamente, especifica ImagenBackgroundMask. Usa editImage() y establece la configuración de edición para usar ImagenEditMode.INPAINT_INSERTION.

// Using this SDK to access Imagen models is a Preview release and requires opt-in
@OptIn(PublicPreviewAPI::class)
suspend fun customizeImage() {
    // Initialize the Vertex AI Gemini API backend service
    // Optionally specify the location to access the model (for example, `us-central1`)
    val ai = Firebase.ai(backend = GenerativeBackend.vertexAI(location = "us-central1"))

    // Create an `ImagenModel` instance with an Imagen "capability" model
    val model = ai.imagenModel("imagen-3.0-capability-001")

    // This example assumes 'originalImage' is a pre-loaded Bitmap.
    // In a real app, this might come from the user's device or a URL.
    val originalImage: Bitmap = TODO("Load your original image Bitmap here")

    // Provide the prompt describing the content to be inserted.
    val prompt = "a vase of flowers on the table"

    // Use the editImage API to insert the new content.
    // Pass the original image, the prompt, and an editing configuration.
    val editedImage = model.editImage(
        sources = listOf(
            ImagenRawImage(originalImage),
            ImagenBackgroundMask(), // Use ImagenBackgroundMask() to auto-generate the mask.
        ),
        prompt = prompt,
        // Define the editing configuration for inpainting and insertion.
        config = ImagenEditingConfig(ImagenEditMode.INPAINT_INSERTION)
    )

    // Process the resulting 'editedImage' Bitmap, for example, by displaying it in an ImageView.
}

Java

Para insertar objetos con una máscara generada automáticamente, especifica ImagenBackgroundMask. Usa editImage() y establece la configuración de edición para usar ImagenEditMode.INPAINT_INSERTION.

// Initialize the Vertex AI Gemini API backend service
// Optionally specify the location to access the model (for example, `us-central1`)
// Create an `ImagenModel` instance with an Imagen "capability" model
ImagenModel imagenModel = FirebaseAI.getInstance(GenerativeBackend.vertexAI("us-central1"))
        .imagenModel(
                /* modelName */ "imagen-3.0-capability-001");

ImagenModelFutures model = ImagenModelFutures.from(imagenModel);

// This example assumes 'originalImage' is a pre-loaded Bitmap.
// In a real app, this might come from the user's device or a URL.
Bitmap originalImage = null; // TODO("Load your image Bitmap here");

// Provide the prompt describing the content to be inserted.
String prompt = "a vase of flowers on the table";

// Define the list of sources for the editImage call.
// This includes the original image and the auto-generated mask.
ImagenRawImage rawOriginalImage = new ImagenRawImage(originalImage);
ImagenBackgroundMask rawMaskedImage = new ImagenBackgroundMask();  // Use ImagenBackgroundMask() to auto-generate the mask.

// Define the editing configuration for inpainting and insertion.
ImagenEditingConfig config = new ImagenEditingConfig.Builder()
        .setEditMode(ImagenEditMode.INPAINT_INSERTION)
        .build();

// Use the editImage API to insert the new content.
// Pass the original image, the auto-generated masked image, the prompt, and an editing configuration.
Futures.addCallback(model.editImage(Arrays.asList(rawOriginalImage, rawMaskedImage), prompt, config), new FutureCallback<ImagenGenerationResponse>() {
    @Override
    public void onSuccess(ImagenGenerationResponse result) {
        if (result.getImages().isEmpty()) {
            Log.d("ImageEditor", "No images generated");
        }
        Bitmap editedImage = result.getImages().get(0).asBitmap();
        // Process and use the bitmap to display the image in your UI
    }

    @Override
    public void onFailure(Throwable t) {
        // ...
    }
}, Executors.newSingleThreadExecutor());

Web

La edición de imágenes con modelos de Imagen no es compatible con las apps web. Vuelve a consultar más adelante este año.

Dart

Para insertar objetos con una máscara generada automáticamente, especifica ImagenBackgroundMask. Usa editImage() y establece la configuración de edición para usar ImagenEditMode.inpaintInsertion.

import 'dart:typed_data';
import 'package:firebase_ai/firebase_ai.dart';
import 'package:firebase_core/firebase_core.dart';
import 'firebase_options.dart';

// Initialize FirebaseApp
await Firebase.initializeApp(
  options: DefaultFirebaseOptions.currentPlatform,
);

// Initialize the Vertex AI Gemini API backend service
// Optionally specify a location to access the model (for example, `us-central1`)
final ai = FirebaseAI.vertexAI(location: 'us-central1');

// Create an `ImagenModel` instance with an Imagen "capability" model
final model = ai.imagenModel(model: 'imagen-3.0-capability-001');

// This example assumes 'originalImage' is a pre-loaded Uint8List.
// In a real app, this might come from the user's device or a URL.
final Uint8List originalImage = Uint8List(0); // TODO: Load your original image data here.

// Provide the prompt describing the content to be inserted.
final prompt = 'a vase of flowers on the table';

try {
  // Use the editImage API to insert the new content.
  // Pass the original image, the prompt, and an editing configuration.
  final response = await model.editImage(
    sources: [
      ImagenRawImage(originalImage),
      ImagenBackgroundMask(), // Use ImagenBackgroundMask() to auto-generate the mask.
    ],
    prompt: prompt,
    // Define the editing configuration for inpainting and insertion.
    config: const ImagenEditingConfig(
      editMode: ImagenEditMode.inpaintInsertion,
    ),
  );

  // Process the result.
  if (response.images.isNotEmpty) {
    final editedImage = response.images.first.bytes;
    // Use the editedImage (a Uint8List) to display the image, save it, etc.
    print('Image successfully generated!');
  } else {
    // Handle the case where no images were generated.
    print('Error: No images were generated.');
  }
} catch (e) {
  // Handle any potential errors during the API call.
  print('An error occurred: $e');
}

Unity

La edición de imágenes con modelos de Imagen no es compatible con Unity. Vuelve a consultar más adelante este año.

Inserta objetos con una máscara proporcionada

Antes de probar esta muestra, completa la sección Antes de comenzar de esta guía para configurar tu proyecto y tu app.

En el siguiente ejemplo, se muestra cómo usar el relleno para insertar contenido en una imagen con una máscara definida en una imagen que proporcionas. Proporcionas la imagen original, una instrucción de texto y la imagen enmascarada.

Swift

La edición de imágenes con modelos de Imagen no se admite en Swift. Vuelve a consultar más adelante este año.

Kotlin

Para insertar objetos y proporcionar tu propia imagen enmascarada, especifica ImagenRawMask con la imagen enmascarada. Usa editImage() y establece la configuración de edición para usar ImagenEditMode.INPAINT_INSERTION.

// Using this SDK to access Imagen models is a Preview release and requires opt-in
@OptIn(PublicPreviewAPI::class)
suspend fun customizeImage() {
    // Initialize the Vertex AI Gemini API backend service
    // Optionally specify the location to access the model (for example, `us-central1`)
    val ai = Firebase.ai(backend = GenerativeBackend.vertexAI(location = "us-central1"))

    // Create an `ImagenModel` instance with an Imagen "capability" model
    val model = ai.imagenModel("imagen-3.0-capability-001")

    // This example assumes 'originalImage' is a pre-loaded Bitmap.
    // In a real app, this might come from the user's device or a URL.
    val originalImage: Bitmap = TODO("Load your original image Bitmap here")

    // This example assumes 'maskImage' is a pre-loaded Bitmap that contains the masked area.
    // In a real app, this might come from the user's device or a URL.
    val maskImage: Bitmap = TODO("Load your masked image Bitmap here")

    // Provide the prompt describing the content to be inserted.
    val prompt = "a vase of flowers on the table"

    // Use the editImage API to insert the new content.
    // Pass the original image, the masked image, the prompt, and an editing configuration.
    val editedImage = model.editImage(
        referenceImages = listOf(
            ImagenRawImage(originalImage.toImagenInlineImage()),
            ImagenRawMask(maskImage.toImagenInlineImage()), // Use ImagenRawMask() to provide your own masked image.
        ),
        prompt = prompt,
        // Define the editing configuration for inpainting and insertion.
        config = ImagenEditingConfig(ImagenEditMode.INPAINT_INSERTION)
    )

    // Process the resulting 'editedImage' Bitmap, for example, by displaying it in an ImageView.
}

Java

Para insertar objetos y proporcionar tu propia imagen enmascarada, especifica ImagenRawMask con la imagen enmascarada. Usa editImage() y establece la configuración de edición para usar ImagenEditMode.INPAINT_INSERTION.

// Initialize the Vertex AI Gemini API backend service
// Optionally specify the location to access the model (for example, `us-central1`)
// Create an `ImagenModel` instance with an Imagen "capability" model
ImagenModel imagenModel = FirebaseAI.getInstance(GenerativeBackend.vertexAI("us-central1"))
        .imagenModel(
                /* modelName */ "imagen-3.0-capability-001");

ImagenModelFutures model = ImagenModelFutures.from(imagenModel);

// This example assumes 'originalImage' is a pre-loaded Bitmap.
// In a real app, this might come from the user's device or a URL.
Bitmap originalImage = null; // TODO("Load your original image Bitmap here");

// This example assumes 'maskImage' is a pre-loaded Bitmap that contains the masked area.
// In a real app, this might come from the user's device or a URL.
Bitmap maskImage = null; // TODO("Load your masked image Bitmap here");

// Provide the prompt describing the content to be inserted.
String prompt = "a vase of flowers on the table";

// Define the list of source images for the editImage call.
ImagenRawImage rawOriginalImage = new ImagenRawImage(originalImage);
ImagenBackgroundMask rawMaskedImage = new ImagenRawMask(maskImage); // Use ImagenRawMask() to provide your own masked image.

// Define the editing configuration for inpainting and insertion.
ImagenEditingConfig config = new ImagenEditingConfig.Builder()
        .setEditMode(ImagenEditMode.INPAINT_INSERTION)
        .build();

// Use the editImage API to insert the new content.
// Pass the original image, the masked image, the prompt, and an editing configuration.
Futures.addCallback(model.editImage(Arrays.asList(rawOriginalImage, rawMaskedImage), prompt, config), new FutureCallback<ImagenGenerationResponse>() {
    @Override
    public void onSuccess(ImagenGenerationResponse result) {
        if (result.getImages().isEmpty()) {
            Log.d("ImageEditor", "No images generated");
        }
        Bitmap editedImage = result.getImages().get(0).asBitmap();
        // Process and use the bitmap to display the image in your UI
    }

    @Override
    public void onFailure(Throwable t) {
        // ...
    }
}, Executors.newSingleThreadExecutor());

Web

La edición de imágenes con modelos de Imagen no es compatible con las apps web. Vuelve a consultar más adelante este año.

Dart

Para insertar objetos y proporcionar tu propia imagen enmascarada, especifica ImagenRawMask con la imagen enmascarada. Usa editImage() y establece la configuración de edición para usar ImagenEditMode.inpaintInsertion.

import 'dart:typed_data';
import 'package:firebase_ai/firebase_ai.dart';
import 'package:firebase_core/firebase_core.dart';
import 'firebase_options.dart';

// Initialize FirebaseApp
await Firebase.initializeApp(
  options: DefaultFirebaseOptions.currentPlatform,
);

// Initialize the Vertex AI Gemini API backend service
// Optionally specify a location to access the model (for example, `us-central1`)
final ai = FirebaseAI.vertexAI(location: 'us-central1');

// Create an `ImagenModel` instance with an Imagen "capability" model
final model = ai.imagenModel(model: 'imagen-3.0-capability-001');

// This example assumes 'originalImage' is a pre-loaded Uint8List.
// In a real app, this might come from the user's device or a URL.
final Uint8List originalImage = Uint8List(0); // TODO: Load your original image data here.

// This example assumes 'maskImage' is a pre-loaded Uint8List that contains the masked area.
// In a real app, this might come from the user's device or a URL.
final Uint8List maskImage = Uint8List(0); // TODO: Load your masked image data here.

// Provide the prompt describing the content to be inserted.
final prompt = 'a vase of flowers on the table';

try {
  // Use the editImage API to insert the new content.
  // Pass the original image, the prompt, and an editing configuration.
  final response = await model.editImage(
    sources: [
      ImagenRawImage(originalImage),
      ImagenRawMask(maskImage), // Use ImagenRawMask() to provide your own masked image.
    ],
    prompt: prompt,
    // Define the editing configuration for inpainting and insertion.
    config: const ImagenEditingConfig(
      editMode: ImagenEditMode.inpaintInsertion,
    ),
  );

  // Process the result.
  if (response.images.isNotEmpty) {
    final editedImage = response.images.first.bytes;
    // Use the editedImage (a Uint8List) to display the image, save it, etc.
    print('Image successfully generated!');
  } else {
    // Handle the case where no images were generated.
    print('Error: No images were generated.');
  }
} catch (e) {
  // Handle any potential errors during the API call.
  print('An error occurred: $e');
}

Unity

La edición de imágenes con modelos de Imagen no es compatible con Unity. Vuelve a consultar más adelante este año.

Prácticas recomendadas y limitaciones

Te recomendamos que dilates la máscara cuando edites una imagen. Esto puede ayudar a suavizar los bordes de una edición y hacer que parezca más convincente. En general, se recomienda un valor de dilatación del 1% o el 2% (0.01 o 0.02).

Enviar comentarios sobre tu experiencia con Firebase AI Logic