Cómo forzar la salida en formato PNG en Nano Banana Pro: 3 formas de resolver problemas de formato de imagen

Nota del autor: Explicación detallada de cómo controlar el formato de salida de imágenes de la API de Nano Banana Pro, guardando como PNG mediante decodificación base64, con ejemplos de código completos.

Al generar imágenes con la API de Nano Banana Pro, muchos desarrolladores se topan con el mismo problema: ¿Cómo forzar la salida en formato PNG en lugar de JPG? En este artículo, responderemos detalladamente a esta pregunta y ofreceremos varias soluciones.

Valor principal: Al finalizar este artículo, dominarás los principios de control de formato de imagen en Nano Banana Pro y aprenderás a decodificar base64 para guardar imágenes en cualquier formato.

Puntos clave del control de salida de imágenes en Nano Banana Pro

¿Por qué la API oficial no ofrece parámetros de control de formato?

Al consultar la documentación oficial de Google AI en ai.google.dev/gemini-api/docs/image-generation, se observa que Nano Banana Pro (basado en la generación de imágenes nativa de Gemini) no ofrece el parámetro output_mime_type, a diferencia de Imagen 3.

Esto se debe a que el diseño de respuesta de la API de Nano Banana Pro difiere de las APIs tradicionales de generación de imágenes:

• Imagen 3: Modelo especializado en generación de imágenes, soporta parámetros como output_mime_type='image/jpeg' o 'image/png'.
• Nano Banana Pro: Capacidad de generación de imágenes de un modelo multimodal, que devuelve datos de imagen originales codificados en base64.

Por lo tanto, el control del formato de imagen en Nano Banana Pro debe realizarse en el lado del cliente (al guardar), no al solicitar la API.

Análisis de la estructura de respuesta inlineData

La estructura de respuesta de la API de Nano Banana Pro es la siguiente:

{
  "candidates": [{
    "content": {
      "parts": [
        {
          "inlineData": {
            "mimeType": "image/png",
            "data": "iVBORw0K..."
          }
        }
      ]
    }
  }]
}

Descripción de los campos clave:

Dado que el campo data contiene los datos de imagen originales en base64, puedes guardarlos en cualquier formato tras la decodificación.

Guía rápida para el control de formato de imagen en Nano Banana Pro

Método 1: Guardar directamente como PNG (Recomendado)

La forma más sencilla es especificar directamente la extensión .png al guardar el archivo:

import google.generativeai as genai
import base64

# Configurar el acceso a APIYI
genai.configure(
    api_key="YOUR_API_KEY",
    transport="rest",
    client_options={"api_endpoint": "https://vip.apiyi.com"}
)

# Generar imagen
model = genai.GenerativeModel("nano-banana-pro")
response = model.generate_content("Un lindo gato naranja, fondo blanco")

# Extraer datos base64 y guardar como PNG
for part in response.candidates[0].content.parts:
    if hasattr(part, 'inline_data') and part.inline_data:
        image_data = base64.b64decode(part.inline_data.data)
        with open("output.png", "wb") as f:
            f.write(image_data)
        print("Imagen guardada en formato PNG")

import google.generativeai as genai
import base64
from PIL import Image
import io
from typing import Literal

class NanoBananaImageSaver:
    """
    Herramienta de conversión de formato de imagen para Nano Banana Pro
    Soporta varios formatos como PNG, JPG, WebP, etc.
    """

    def __init__(self, api_key: str):
        genai.configure(
            api_key=api_key,
            transport="rest",
            client_options={"api_endpoint": "https://vip.apiyi.com"}
        )
        self.model = genai.GenerativeModel("nano-banana-pro")

    def generate_and_save(
        self,
        prompt: str,
        output_path: str,
        format: Literal["PNG", "JPEG", "WEBP"] = "PNG",
        quality: int = 95
    ) -> bool:
        """
        Genera una imagen y la guarda en el formato especificado

        Args:
            prompt: Indicación de generación
            output_path: Ruta del archivo de salida
            format: Formato de salida (PNG/JPEG/WEBP)
            quality: Calidad de compresión (solo válida para JPEG/WEBP, 1-100)
        """
        try:
            response = self.model.generate_content(prompt)

            for part in response.candidates[0].content.parts:
                if hasattr(part, 'inline_data') and part.inline_data:
                    # Decodificar base64
                    image_data = base64.b64decode(part.inline_data.data)

                    # Abrir con PIL y convertir el formato
                    image = Image.open(io.BytesIO(image_data))

                    # Manejar el canal alfa (necesario para PNG → JPEG)
                    if format == "JPEG" and image.mode == "RGBA":
                        # Crear fondo blanco
                        background = Image.new("RGB", image.size, (255, 255, 255))
                        background.paste(image, mask=image.split()[3])
                        image = background

                    # Guardar en el formato especificado
                    save_params = {}
                    if format in ["JPEG", "WEBP"]:
                        save_params["quality"] = quality

                    image.save(output_path, format=format, **save_params)
                    print(f"Imagen guardada: {output_path} (Formato: {format})")
                    return True

            return False
        except Exception as e:
            print(f"Error al guardar: {e}")
            return False


# Ejemplo de uso
if __name__ == "__main__":
    saver = NanoBananaImageSaver("YOUR_API_KEY")

    # Guardar como PNG (sin pérdida, mantiene canal alfa)
    saver.generate_and_save(
        prompt="Fachada de edificio moderno, fondo transparente",
        output_path="building.png",
        format="PNG"
    )

    # Guardar como JPEG (compresión con pérdida, archivo más pequeño)
    saver.generate_and_save(
        prompt="Fotografía de paisaje, playa al atardecer",
        output_path="sunset.jpg",
        format="JPEG",
        quality=85
    )

    # Guardar como WebP (formato moderno, buen equilibrio entre calidad y peso)
    saver.generate_and_save(
        prompt="Imagen de exhibición de producto",
        output_path="product.webp",
        format="WEBP",
        quality=90
    )

Sugerencia: Obtén acceso a la API de Nano Banana Pro a través de APIYI (apiyi.com). La plataforma ofrece un servicio de acceso estable a un precio que es solo el 20% del oficial y soporta llamadas por lotes.

Comparativa de formatos de imagen en Nano Banana Pro

Descripción detallada de cada formato

Cuándo usar PNG:

• Material de diseño que requiere fondo transparente.
• Escenarios con exigencias de calidad de imagen extremadamente altas.
• Materiales intermedios que requieren ediciones recurrentes.
• Iconos, logotipos y otras imágenes que necesitan bordes nítidos.

Cuándo usar JPEG:

• Imágenes de tipo fotográfico (paisajes, retratos, fotos reales de productos).
• Cuando necesitas controlar el peso del archivo para transferencia web.
• Compartir en redes sociales.
• Imágenes generales que no requieren fondo transparente.

Cuándo usar WebP:

• Aplicaciones web modernas (alta compatibilidad con navegadores).
• Imágenes integradas en Apps móviles.
• Escenarios donde se busca equilibrar calidad y peso.
• Escenarios que soportan animaciones (puede reemplazar al GIF).

Uso avanzado de conversión de formatos de imagen con Nano Banana Pro

Implementación en Node.js

const { GoogleGenerativeAI } = require("@google/generative-ai");
const fs = require("fs");
const sharp = require("sharp");

async function generateAndSave(prompt, outputPath, format = "png") {
  const genAI = new GoogleGenerativeAI("YOUR_API_KEY");
  const model = genAI.getGenerativeModel({ model: "nano-banana-pro" });

  const result = await model.generateContent(prompt);
  const response = await result.response;

  for (const part of response.candidates[0].content.parts) {
    if (part.inlineData) {
      const buffer = Buffer.from(part.inlineData.data, "base64");

      // Usar sharp para convertir el formato
      let sharpInstance = sharp(buffer);

      switch (format.toLowerCase()) {
        case "png":
          sharpInstance = sharpInstance.png();
          break;
        case "jpeg":
        case "jpg":
          sharpInstance = sharpInstance.jpeg({ quality: 85 });
          break;
        case "webp":
          sharpInstance = sharpInstance.webp({ quality: 90 });
          break;
      }

      await sharpInstance.toFile(outputPath);
      console.log(`Imagen guardada: ${outputPath}`);
    }
  }
}

// Forzar salida a PNG
generateAndSave("Un personaje de dibujos animados adorable", "character.png", "png");

Versión para línea de comandos (cURL)

# Llamar a la API y guardar como PNG
curl -X POST "https://vip.apiyi.com/v1/models/nano-banana-pro:generateContent" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{"contents":[{"parts":[{"text":"Un gato naranja adorable"}]}]}' \
  | jq -r '.candidates[0].content.parts[] | select(.inlineData) | .inlineData.data' \
  | base64 --decode > output.png

echo "Imagen guardada como output.png"

Preguntas Frecuentes

Resumen

Puntos clave para el control del formato de imagen en Nano Banana Pro:

1. La API devuelve codificación base64: inlineData.data contiene los datos crudos de forma neutral; puedes elegir libremente el formato al guardar.
2. El proveedor oficial no ofrece parámetros de formato: A diferencia de Imagen 3, Nano Banana Pro no admite el parámetro output_mime_type.
3. El cliente controla el formato de salida: Tras decodificar el base64, utiliza herramientas como PIL (Python) o Sharp (Node.js) para guardar la imagen en PNG, JPEG o WebP.
4. Elige el formato según el escenario: PNG es ideal para materiales de diseño, JPEG para fotografías y WebP para aplicaciones web modernas.

Una vez que comprendas el principio de la decodificación base64, tendrás el control total sobre el formato de salida de las imágenes generadas por Nano Banana Pro.

Te recomendamos obtener acceso a la API de Nano Banana Pro a través de APIYI (apiyi.com). La plataforma ofrece un servicio estable, con precios que son apenas el 20% de los oficiales y soporte para generación por lotes.

📚 Referencias

⚠️ Nota sobre el formato de los enlaces: Todos los enlaces externos utilizan el formato Nombre del recurso: dominio.com. Están diseñados para ser fáciles de copiar pero no son clicables, evitando así la transferencia de autoridad SEO.

1. Documentación de generación de imágenes de Google AI: Guía oficial de mejores prácticas de la API.

   • Enlace: ai.google.dev/gemini-api/docs/image-generation
   • Descripción: Incluye la estructura de respuesta de inlineData y ejemplos de código.

2. Documentación de Pillow (PIL): Librería de procesamiento de imágenes para Python.

   • Enlace: pillow.readthedocs.io
   • Descripción: Soporta la lectura, conversión y guardado de múltiples formatos de imagen.

3. Documentación de Sharp: Librería de procesamiento de imágenes de alto rendimiento para Node.js.

   • Enlace: sharp.pixelplumbing.com
   • Descripción: Soporta conversión a formatos PNG/JPEG/WebP con un rendimiento excelente.

4. Sección de Nano Banana Pro en APIYI: Documentación de integración.

   • Enlace: apiyi.com
   • Descripción: Ofrece documentación en español, ejemplos de código y detalles de precios.

Autor: Equipo técnico
Intercambio técnico: Te invitamos a discutir tus trucos de uso de Nano Banana Pro en la sección de comentarios. Para más materiales, puedes visitar la comunidad técnica de APIYI (apiyi.com).