Nano Banana Pro : comment forcer la sortie au format PNG : 3 méthodes pour résoudre les problèmes de format d’image

Note de l'auteur : Explication détaillée des méthodes de contrôle du format de sortie d'image de l'API Nano Banana Pro, via le décodage base64 pour une sauvegarde en PNG, accompagnée d'exemples de code complets.

Lors de l'utilisation de l'API Nano Banana Pro pour générer des images, de nombreux développeurs se heurtent à une question : comment forcer une sortie au format PNG plutôt qu'en JPG ? Cet article répondra en détail à cette question et proposera plusieurs solutions de mise en œuvre.

Valeur ajoutée : En lisant cet article, vous maîtriserez les principes de contrôle du format d'image de Nano Banana Pro et apprendrez à utiliser le décodage base64 pour sauvegarder vos images dans n'importe quel format.

Points clés de la sortie du format d'image Nano Banana Pro

Pourquoi aucun paramètre de contrôle de format n'est-il fourni officiellement ?

En consultant la documentation officielle de Google AI ai.google.dev/gemini-api/docs/image-generation, on constate que Nano Banana Pro (basé sur la génération d'images native de Gemini) ne propose pas de paramètre output_mime_type contrairement à Imagen 3.

C'est parce que la conception de la réponse API de Nano Banana Pro diffère des API de génération d'images traditionnelles :

• Imagen 3 : Modèle de génération d'images dédié, supportant les paramètres output_mime_type='image/jpeg' ou 'image/png'.
• Nano Banana Pro : Capacité de génération d'images intégrée à un grand modèle de langage multimodal, renvoyant les données brutes de l'image encodées en base64.

Par conséquent, le contrôle du format d'image pour Nano Banana Pro s'effectue au moment de l'enregistrement côté client, et non lors de la requête API.

Analyse de la structure de réponse inlineData

La structure de la réponse de l'API Nano Banana Pro est la suivante :

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

Description des champs clés :

Comme le champ data contient les données d'image brutes encodées en base64, vous pouvez les enregistrer dans n'importe quel format après décodage.

Prise en main rapide du contrôle du format d'image avec Nano Banana Pro

Méthode 1 : Enregistrer directement en PNG (recommandé)

La méthode la plus simple consiste à spécifier directement l'extension .png lors de l'enregistrement :

import google.generativeai as genai
import base64

# 配置 APIYI 接入
genai.configure(
    api_key="YOUR_API_KEY",
    transport="rest",
    client_options={"api_endpoint": "https://vip.apiyi.com"}
)

# 生成图片
model = genai.GenerativeModel("nano-banana-pro")
response = model.generate_content("一只可爱的橘猫，白色背景")

# 提取 base64 数据并保存为 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("图片已保存为 PNG 格式")

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

class NanoBananaImageSaver:
    """
    Nano Banana Pro 图片格式转换工具
    支持 PNG、JPG、WebP 等多种格式
    """

    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:
        """
        生成图片并保存为指定格式

        Args:
            prompt: 生成提示词
            output_path: 输出文件路径
            format: 输出格式 (PNG/JPEG/WEBP)
            quality: 压缩质量 (仅对 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:
                    # 解码 base64
                    image_data = base64.b64decode(part.inline_data.data)

                    # 使用 PIL 打开并转换格式
                    image = Image.open(io.BytesIO(image_data))

                    # 处理透明通道 (PNG → JPEG 需要)
                    if format == "JPEG" and image.mode == "RGBA":
                        # 创建白色背景
                        background = Image.new("RGB", image.size, (255, 255, 255))
                        background.paste(image, mask=image.split()[3])
                        image = background

                    # 保存为指定格式
                    save_params = {}
                    if format in ["JPEG", "WEBP"]:
                        save_params["quality"] = quality

                    image.save(output_path, format=format, **save_params)
                    print(f"图片已保存: {output_path} (格式: {format})")
                    return True

            return False
        except Exception as e:
            print(f"保存失败: {e}")
            return False


# 使用示例
if __name__ == "__main__":
    saver = NanoBananaImageSaver("YOUR_API_KEY")

    # 保存为 PNG (无损，保留透明通道)
    saver.generate_and_save(
        prompt="现代建筑外观，透明背景",
        output_path="building.png",
        format="PNG"
    )

    # 保存为 JPEG (有损压缩，文件更小)
    saver.generate_and_save(
        prompt="风景照片，落日海滩",
        output_path="sunset.jpg",
        format="JPEG",
        quality=85
    )

    # 保存为 WebP (现代格式，兼顾质量和体积)
    saver.generate_and_save(
        prompt="产品展示图",
        output_path="product.webp",
        format="WEBP",
        quality=90
    )

Conseil : Obtenez l'accès à l'API Nano Banana Pro via APIYI (apiyi.com). La plateforme offre un service d'accès stable à un prix 80 % moins cher que le site officiel, avec prise en charge des appels par lots.

Comparaison des solutions de format d'image Nano Banana Pro

Description détaillée des formats

Cas d'utilisation du format PNG :

• Éléments de design nécessitant de conserver un fond transparent.
• Scénarios exigeant une qualité d'image extrêmement élevée.
• Ressources intermédiaires nécessitant des modifications répétées.
• Icônes, logos et images nécessitant des contours nets.

Cas d'utilisation du format JPEG :

• Images de type photographique (paysages, portraits, photos de produits).
• Transferts réseau nécessitant un contrôle de la taille des fichiers.
• Partage sur les réseaux sociaux.
• Images générales ne nécessitant pas de fond transparent.

Cas d'utilisation du format WebP :

• Applications Web modernes (excellente prise en charge par les navigateurs).
• Images intégrées dans les applications mobiles.
• Scénarios nécessitant à la fois une bonne qualité et un faible volume.
• Scénarios prenant en charge l'animation (peut remplacer le GIF).

Utilisation avancée de la conversion de format d'image avec Nano Banana Pro

Implémentation de la version 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");

      // Utilisation de sharp pour convertir le format
      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(`Image enregistrée : ${outputPath}`);
    }
  }
}

// Force la sortie en PNG
generateAndSave("Un personnage de dessin animé mignon", "character.png", "png");

Version en ligne de commande cURL

# Appeler l'API et enregistrer en tant que 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 chat roux mignon"}]}]}' \
  | jq -r '.candidates[0].content.parts[] | select(.inlineData) | .inlineData.data' \
  | base64 --decode > output.png

echo "Image enregistrée sous output.png"

Questions fréquentes

Résumé

Points clés du contrôle du format d'image avec Nano Banana Pro :

1. L'API renvoie un encodage base64 : inlineData.data contient des données brutes neutres vis-à-vis du format, ce qui vous permet de choisir librement le format lors de l'enregistrement.
2. Aucun paramètre de format fourni officiellement : contrairement à Imagen 3, Nano Banana Pro ne prend pas en charge le paramètre output_mime_type.
3. Contrôle du format de sortie côté client : après le décodage base64, utilisez des outils comme PIL ou sharp pour sauvegarder l'image en PNG, JPEG ou WebP.
4. Choisissez le format selon vos besoins : le PNG est idéal pour les ressources de design, le JPEG pour les photos, et le WebP pour les applications Web modernes.

Une fois le principe du décodage base64 maîtrisé, vous avez un contrôle total sur le format de sortie des images générées par Nano Banana Pro.

Nous vous recommandons d'utiliser APIYI (apiyi.com) pour accéder à l'API Nano Banana Pro. La plateforme offre un service stable, avec des tarifs environ 80 % moins chers que les prix officiels, et supporte la génération par lots.

📚 Ressources de référence

⚠️ Note sur le format des liens : Tous les liens externes utilisent le format Nom de la ressource : domain.com. Ils sont faciles à copier mais ne sont pas cliquables, afin de préserver le référencement (SEO).

1. Documentation Google AI sur la génération d'images : Guide officiel des bonnes pratiques de l'API

   • Lien : ai.google.dev/gemini-api/docs/image-generation
   • Description : contient la structure de réponse inlineData et des exemples de code.

2. Documentation Pillow (PIL) : Bibliothèque de traitement d'images pour Python

   • Lien : pillow.readthedocs.io
   • Description : supporte la lecture, la conversion et l'enregistrement de nombreux formats d'image.

3. Documentation Sharp : Bibliothèque de traitement d'images haute performance pour Node.js

   • Lien : sharp.pixelplumbing.com
   • Description : permet la conversion vers les formats PNG/JPEG/WebP avec d'excellentes performances.

4. Espace Nano Banana Pro sur APIYI : Documentation d'intégration

   • Lien : apiyi.com
   • Description : propose de la documentation, des exemples de code et les détails de tarification.

Auteur : Équipe technique
Échanges techniques : N'hésitez pas à partager vos astuces sur Nano Banana Pro dans la section commentaires. Pour plus de ressources, rejoignez la communauté technique d'APIYI sur apiyi.com.