Nano Banana Pro Como Forçar a Saída em PNG: 3 Métodos para Resolver Problemas de Formato de Imagem

Nota do autor: Detalhes sobre o método de controle do formato de saída de imagem da API Nano Banana Pro, com decodificação base64 e salvamento como PNG, incluindo exemplo de código completo.

Ao usar a API Nano Banana Pro para gerar imagens, muitos desenvolvedores enfrentam um problema: como forçar a saída em PNG em vez do formato JPG? Este artigo responderá a essa pergunta em detalhes e fornecerá várias soluções de implementação.

Valor Principal: Ao ler este artigo, você dominará os princípios de controle de formato de imagem do Nano Banana Pro e aprenderá a salvar imagens em qualquer formato através da decodificação base64.

Pontos Principais da Saída de Formato de Imagem do Nano Banana Pro

Por que a versão oficial não oferece parâmetros de controle de formato?

Ao consultar a documentação oficial da Google AI em ai.google.dev/gemini-api/docs/image-generation, percebe-se que o Nano Banana Pro (baseado na geração de imagens nativa do Gemini) não oferece o parâmetro output_mime_type como o Imagen 3.

Isso ocorre porque o design da resposta da API do Nano Banana Pro difere das APIs tradicionais de geração de imagem:

• Imagen 3: Modelo especializado em geração de imagens, suporta parâmetros como output_mime_type='image/jpeg' ou 'image/png'.
• Nano Banana Pro: Capacidade de geração de imagens de um modelo multimodal, retornando dados de imagem brutos codificados em base64.

Portanto, o controle do formato de imagem do Nano Banana Pro deve ser feito no lado do cliente (no momento do salvamento) e não na requisição da API.

Análise da Estrutura de Resposta inlineData

A estrutura da resposta da API Nano Banana Pro é a seguinte:

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

Descrição dos campos principais:

Como o campo data contém os dados de imagem brutos em base64, você pode salvá-los em qualquer formato após a decodificação.

Guia rápido de controle de formato de imagem no Nano Banana Pro

Método 1: Salvar diretamente como PNG (Recomendado)

O jeito mais fácil é especificar a extensão .png diretamente na hora de salvar:

import google.generativeai as genai
import base64

# Configura o acesso via APIYI
genai.configure(
    api_key="YOUR_API_KEY",
    transport="rest",
    client_options={"api_endpoint": "https://vip.apiyi.com"}
)

# Gera a imagem
model = genai.GenerativeModel("nano-banana-pro")
response = model.generate_content("Um gato alaranjado fofo, fundo branco")

# Extrai os dados base64 e salva 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("Imagem salva no formato PNG")

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

class NanoBananaImageSaver:
    """
    Ferramenta de conversão de formato de imagem Nano Banana Pro
    Suporta PNG, JPG, WebP e outros formatos
    """

    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:
        """
        Gera a imagem e a salva no formato especificado

        Args:
            prompt: comando de geração
            output_path: caminho do arquivo de saída
            format: formato de saída (PNG/JPEG/WEBP)
            quality: qualidade da compressão (válido apenas 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:
                    # Decodifica o base64
                    image_data = base64.b64decode(part.inline_data.data)

                    # Abre com PIL e converte o formato
                    image = Image.open(io.BytesIO(image_data))

                    # Trata o canal de transparência (necessário para PNG → JPEG)
                    if format == "JPEG" and image.mode == "RGBA":
                        # Cria um fundo branco
                        background = Image.new("RGB", image.size, (255, 255, 255))
                        background.paste(image, mask=image.split()[3])
                        image = background

                    # Salva no formato especificado
                    save_params = {}
                    if format in ["JPEG", "WEBP"]:
                        save_params["quality"] = quality

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

            return False
        except Exception as e:
            print(f"Erro ao salvar: {e}")
            return False


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

    # Salva como PNG (sem perdas, mantém canal de transparência)
    saver.generate_and_save(
        prompt="Fachada de arquitetura moderna, fundo transparente",
        output_path="predio.png",
        format="PNG"
    )

    # Salva como JPEG (compressão com perdas, arquivo menor)
    saver.generate_and_save(
        prompt="Foto de paisagem, pôr do sol na praia",
        output_path="por_do_sol.jpg",
        format="JPEG",
        quality=85
    )

    # Salva como WebP (formato moderno, equilibra qualidade e tamanho)
    saver.generate_and_save(
        prompt="Foto de demonstração de produto",
        output_path="produto.webp",
        format="WEBP",
        quality=90
    )

Dica: Obtenha acesso à API do Nano Banana Pro através do APIYI (apiyi.com). A plataforma oferece um serviço de acesso estável, com preços até 80% menores que os oficiais e suporte para chamadas em lote.

Comparação de Formatos de Imagem no Nano Banana Pro

Detalhes sobre cada formato

Quando usar PNG:

• Materiais de design que precisam manter o fundo transparente.
• Cenários onde a qualidade máxima da imagem é indispensável.
• Arquivos intermediários que passarão por várias edições.
• Ícones e logotipos que precisam de bordas nítidas.

Quando usar JPEG:

• Imagens fotográficas (paisagens, retratos, fotos reais de produtos).
• Quando o foco é reduzir o tamanho do arquivo para transmissão web.
• Compartilhamento em redes sociais.
• Imagens genéricas que não precisam de transparência.

Quando usar WebP:

• Aplicações web modernas (amplo suporte nos navegadores atuais).
• Imagens internas de aplicativos móveis (Android/iOS).
• Cenários que exigem o melhor equilíbrio entre qualidade visual e peso do arquivo.
• Substituição de GIFs (suporta animações com compressão muito superior).

Uso Avançado de Conversão de Formato de Imagem com Nano Banana Pro

Implementação em 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 converter o 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(`Imagem salva em: ${outputPath}`);
    }
  }
}

// Forçar saída em PNG
generateAndSave("Um personagem de desenho animado fofo", "character.png", "png");

Versão de linha de comando cURL

# Chamar a API e salvar 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":"Um gato laranja fofo"}]}]}' \
  | jq -r '.candidates[0].content.parts[] | select(.inlineData) | .inlineData.data' \
  | base64 --decode > output.png

echo "Imagem salva como output.png"

Perguntas Frequentes

Resumo

Pontos principais do controle de formato de imagem no Nano Banana Pro:

1. A API retorna codificação base64: inlineData.data são dados brutos neutros em termos de formato, permitindo escolher o formato livremente ao salvar.
2. A documentação oficial não fornece parâmetros de formato: Diferente do Imagen 3, o Nano Banana Pro não suporta o parâmetro output_mime_type.
3. Controle do formato de saída pelo cliente: Após a decodificação base64, use ferramentas como PIL ou sharp para salvar como PNG, JPEG ou WebP.
4. Escolha o formato conforme o cenário: PNG é ideal para materiais de design, JPEG para fotos e WebP para aplicações web modernas.

Ao entender o princípio da decodificação base64, você terá controle total sobre o formato de saída das imagens geradas pelo Nano Banana Pro.

Recomendamos obter acesso à API do Nano Banana Pro via APIYI (apiyi.com). A plataforma oferece serviços estáveis, preços com 80% de desconto em relação ao site oficial e suporte para geração em lote.

📚 Referências

⚠️ Nota sobre o formato dos links: Todos os links externos utilizam o formato Nome do Recurso: domain.com. Isso facilita a cópia, mas evita cliques diretos para prevenir a perda de autoridade de SEO.

1. Documentação de Geração de Imagens do Google AI: Guia oficial de melhores práticas da API

   • Link: ai.google.dev/gemini-api/docs/image-generation
   • Descrição: Contém a estrutura de resposta inlineData e exemplos de código.

2. Documentação do Pillow (PIL): Biblioteca de processamento de imagem para Python

   • Link: pillow.readthedocs.io
   • Descrição: Suporta leitura, conversão e salvamento de diversos formatos de imagem.

3. Documentação do Sharp: Biblioteca de processamento de imagem de alto desempenho para Node.js

   • Link: sharp.pixelplumbing.com
   • Descrição: Suporta conversão entre formatos PNG/JPEG/WebP com excelente desempenho.

4. Seção Nano Banana Pro na APIYI: Documentação de integração em chinês

   • Link: apiyi.com
   • Descrição: Oferece documentação em chinês, exemplos de código e detalhes de preços.

Autor: Equipe Técnica
Troca de Conhecimento Técnico: Sinta-se à vontade para discutir dicas de uso do Nano Banana Pro na seção de comentários. Para mais recursos, acesse a comunidade técnica da APIYI em apiyi.com.