Cara Memaksa Nano Banana Pro Mengeluarkan Format PNG: 3 Cara Mengatasi Masalah Format Gambar

Catatan Penulis: Penjelasan mendalam tentang cara mengontrol format output gambar Nano Banana Pro API, menyimpannya sebagai PNG melalui dekode base64, dilengkapi dengan contoh kode lengkap.

Saat menggunakan Nano Banana Pro API untuk menghasilkan gambar, banyak pengembang menghadapi masalah: Bagaimana cara memaksa output format PNG alih-alih JPG? Artikel ini akan menjawab pertanyaan tersebut secara rinci dan memberikan berbagai solusi implementasi.

Nilai Inti: Setelah membaca artikel ini, Anda akan menguasai prinsip kontrol format gambar Nano Banana Pro dan belajar cara menyimpan gambar dalam format apa pun melalui dekode base64.

Poin Utama Kontrol Output Format Gambar Nano Banana Pro

Mengapa tidak ada parameter kontrol format resmi?

Jika Anda memeriksa dokumentasi resmi Google AI di ai.google.dev/gemini-api/docs/image-generation, Anda akan menemukan bahwa Nano Banana Pro (yang didasarkan pada pembuatan gambar asli Gemini) tidak menyediakan parameter output_mime_type seperti halnya Imagen 3.

Hal ini dikarenakan desain respons API Nano Banana Pro berbeda dari API pembuatan gambar tradisional:

• Imagen 3: Model pembuatan gambar khusus yang mendukung parameter output_mime_type='image/jpeg' atau 'image/png'.
• Nano Banana Pro: Kemampuan pembuatan gambar dari model multimodal, yang mengembalikan data gambar mentah dalam pengodean base64.

Oleh karena itu, kontrol format gambar Nano Banana Pro perlu dilakukan di sisi klien (saat proses penyimpanan), bukan ditentukan saat permintaan API dilakukan.

Analisis Struktur Respons inlineData

Struktur respons API Nano Banana Pro adalah sebagai berikut:

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

Penjelasan field kunci:

Karena field data adalah data gambar mentah yang dikodekan dengan base64, Anda dapat menyimpannya ke dalam format apa pun setelah didekode.

Memulai Cepat Kontrol Format Gambar Nano Banana Pro

Metode 1: Simpan langsung sebagai PNG (Direkomendasikan)

Cara termudah adalah dengan menentukan ekstensi .png secara langsung saat menyimpan:

import google.generativeai as genai
import base64

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

# Hasilkan gambar
model = genai.GenerativeModel("nano-banana-pro")
response = model.generate_content("seekor kucing oren yang lucu, latar belakang putih")

# Ekstrak data base64 dan simpan sebagai 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("Gambar telah disimpan dalam format PNG")

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

class NanoBananaImageSaver:
    """
    Alat konversi format gambar Nano Banana Pro
    Mendukung berbagai format seperti PNG, JPG, WebP, dll.
    """

    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:
        """
        Hasilkan gambar dan simpan ke format yang ditentukan

        Args:
            prompt: petunjuk pembuatan gambar
            output_path: jalur file output
            format: format output (PNG/JPEG/WEBP)
            quality: kualitas kompresi (hanya berlaku untuk 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:
                    # Dekode base64
                    image_data = base64.b64decode(part.inline_data.data)

                    # Gunakan PIL untuk membuka dan mengubah format
                    image = Image.open(io.BytesIO(image_data))

                    # Menangani saluran transparansi (diperlukan untuk konversi PNG → JPEG)
                    if format == "JPEG" and image.mode == "RGBA":
                        # Buat latar belakang putih
                        background = Image.new("RGB", image.size, (255, 255, 255))
                        background.paste(image, mask=image.split()[3])
                        image = background

                    # Simpan ke format yang ditentukan
                    save_params = {}
                    if format in ["JPEG", "WEBP"]:
                        save_params["quality"] = quality

                    image.save(output_path, format=format, **save_params)
                    print(f"Gambar telah disimpan: {output_path} (Format: {format})")
                    return True

            return False
        except Exception as e:
            print(f"Gagal menyimpan: {e}")
            return False


# Contoh penggunaan
if __name__ == "__main__":
    saver = NanoBananaImageSaver("YOUR_API_KEY")

    # Simpan sebagai PNG (lossless, mempertahankan saluran transparansi)
    saver.generate_and_save(
        prompt="Eksterior bangunan modern, latar belakang transparan",
        output_path="building.png",
        format="PNG"
    )

    # Simpan sebagai JPEG (kompresi lossy, ukuran file lebih kecil)
    saver.generate_and_save(
        prompt="Foto pemandangan, pantai saat matahari terbenam",
        output_path="sunset.jpg",
        format="JPEG",
        quality=85
    )

    # Simpan sebagai WebP (format modern, menyeimbangkan kualitas dan ukuran)
    saver.generate_and_save(
        prompt="Gambar produk",
        output_path="product.webp",
        format="WEBP",
        quality=90
    )

Saran: Dapatkan akses Nano Banana Pro API melalui APIYI apiyi.com. Platform ini menyediakan layanan akses yang stabil, harga hanya 20% dari harga resmi, dan mendukung panggilan massal.

Perbandingan Solusi Format Gambar Nano Banana Pro

Penjelasan Detail Setiap Format

Skenario Penggunaan Format PNG:

• Butuh mempertahankan latar belakang transparan untuk materi desain.
• Skenario dengan persyaratan kualitas gambar yang sangat tinggi.
• Materi perantara yang membutuhkan pengeditan berulang.
• Ikon, Logo, atau gambar lain yang membutuhkan tepian yang tajam.

Skenario Penggunaan Format JPEG:

• Gambar jenis foto (pemandangan, potret, produk asli).
• Perlu mengontrol ukuran file untuk transmisi jaringan.
• Berbagi di media sosial.
• Gambar umum yang tidak membutuhkan latar belakang transparan.

Skenario Penggunaan Format WebP:

• Aplikasi Web modern (didukung dengan baik oleh browser).
• Gambar yang disematkan dalam aplikasi seluler.
• Skenario yang perlu menyeimbangkan antara kualitas dan ukuran file.
• Skenario yang mendukung animasi (dapat menggantikan GIF).

Penggunaan Lanjutan Konversi Format Gambar Nano Banana Pro

Implementasi Versi 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");

      // Gunakan sharp untuk konversi 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(`Gambar telah disimpan: ${outputPath}`);
    }
  }
}

// Paksa output ke PNG
generateAndSave("Karakter kartun yang lucu", "character.png", "png");

Versi Baris Perintah cURL

# Panggil API dan simpan sebagai 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":"Seekor kucing oranye yang lucu"}]}]}' \
  | jq -r '.candidates[0].content.parts[] | select(.inlineData) | .inlineData.data' \
  | base64 --decode > output.png

echo "Gambar telah disimpan sebagai output.png"

FAQ (Pertanyaan Umum)

Ringkasan

Poin-poin utama kontrol format gambar Nano Banana Pro:

1. API mengembalikan encoding base64: inlineData.data adalah data mentah yang bebas format, Anda dapat bebas memilih format saat menyimpannya.
2. Tidak ada parameter format resmi: Berbeda dengan Imagen 3, Nano Banana Pro tidak mendukung parameter output_mime_type.
3. Kontrol format output di sisi klien: Gunakan alat seperti PIL/sharp untuk menyimpan sebagai PNG/JPEG/WebP setelah melakukan dekode base64.
4. Pilih format berdasarkan kebutuhan: PNG cocok untuk aset desain, JPEG untuk foto, dan WebP untuk aplikasi web modern.

Setelah memahami prinsip dekode base64, Anda dapat memegang kendali penuh atas format output gambar yang dihasilkan oleh Nano Banana Pro.

Sangat direkomendasikan untuk mendapatkan akses API Nano Banana Pro melalui APIYI (apiyi.com). Platform ini menyediakan layanan yang stabil dengan harga hanya 20% dari harga resmi, serta mendukung pembuatan gambar secara massal.

📚 Referensi

⚠️ Catatan Format Tautan: Semua tautan luar menggunakan format Nama Sumber: domain.com. Ini memudahkan untuk disalin tetapi tidak dapat diklik langsung guna menghindari hilangnya bobot SEO.

1. Dokumentasi Google AI Image Generation: Panduan praktik terbaik API resmi

   • Tautan: ai.google.dev/gemini-api/docs/image-generation
   • Keterangan: Berisi struktur respons inlineData dan contoh kode

2. Dokumentasi Pillow (PIL): Pustaka pemrosesan gambar Python

   • Tautan: pillow.readthedocs.io
   • Keterangan: Mendukung pembacaan, konversi, dan penyimpanan berbagai format gambar

3. Dokumentasi Sharp: Pustaka pemrosesan gambar berperforma tinggi untuk Node.js

   • Tautan: sharp.pixelplumbing.com
   • Keterangan: Mendukung konversi format PNG/JPEG/WebP dengan performa luar biasa

4. Area Khusus APIYI Nano Banana Pro: Dokumentasi integrasi

   • Tautan: apiyi.com
   • Keterangan: Menyediakan dokumentasi, contoh kode, dan rincian harga

Penulis: Tim Teknis
Diskusi Teknis: Selamat berdiskusi tentang tips penggunaan Nano Banana Pro di kolom komentar. Untuk informasi lebih lanjut, silakan kunjungi komunitas teknis APIYI apiyi.com