Canal alfa real na OpenAI Image API: como gerar e verificar PNGs transparentes

Quando interfaces de usuário ou apresentações exigem assets gráficos — como ícones ou ilustrações pontuais —, o requisito principal é direto: um fundo transparente autêntico salvo no formato PNG.

Na prática, trabalhar com modelos generativos de imagem apresenta dois problemas frequentes:

1. O modelo desenha o padrão xadrez simulado de transparência diretamente nos pixels da imagem rasterizada (pseudotransparência), retornando uma imagem totalmente opaca.
2. O arquivo de fato contém um canal alfa, mas as bordas do objeto exibem contornos indesejados ou halos (fringing), fazendo com que o asset pareça mal-acabado sobre fundos variados.

Embora os parâmetros da API permitam solicitar transparência, o formato de saída e a qualidade das bordas ainda exigem verificação. A seguir, veremos como configurar a requisição, estruturar o prompt e validar rapidamente o PNG resultante.

---

1. Parâmetros da API e estruturação do prompt

A edição de imagens existentes (Edits) é uma tarefa à parte; aqui, focamos na geração de novos assets do zero (Generations).

De acordo com o OpenAI Image Generation Guide, a transparência é controlada combinando dois parâmetros:

• background: aceita transparent, opaque ou auto. Especifique transparent para solicitar um fundo transparente.
• output_format: defina como png (ou webp), já que o jpeg não suporta canal alfa.

O parâmetro da API solicita a transparência no nível do formato, mas o prompt também precisa isolar explicitamente o objeto e proibir elementos indesejados ao redor.

As recomendações do OpenAI Image Prompting Guide ajudam a eliminar elementos parasitas:

An isolated 3D isometric glass cube with glowing layered circuit boards inside, modern tech UI asset, smooth glossy reflections, crisp defined edges, centered composition, fully isolated on a transparent background, no drop shadow, no solid backdrop, no floor reflection, no checkerboard pattern.

Essa descrição fixa o assunto com limites bem definidos (crisp defined edges) e exclui explicitamente sombras projetadas (no drop shadow), planos de fundo sólidos (no solid backdrop) e grades de transparência simuladas (no checkerboard pattern).

---

2. Gerando imagens via API em Python

Para enviar requisições à API, utilize a biblioteca oficial openai:

import base64
from openai import OpenAI

client = OpenAI()

prompt = (
    "An isolated 3D isometric glass cube with glowing layered circuit boards inside, "
    "modern tech UI asset, smooth glossy reflections, crisp defined edges, "
    "centered composition, fully isolated on a transparent background, "
    "no drop shadow, no solid backdrop, no floor reflection, no checkerboard pattern"
)

response = client.images.generate(
    model="gpt-image-2.5-flare",
    prompt=prompt,
    background="transparent",
    output_format="png",
)

image_b64 = response.data[0].b64_json
image_bytes = base64.b64decode(image_b64)

with open("ui_cube_asset.png", "wb") as file:
    file.write(image_bytes)

---

3. Verificando o canal alfa e as bordas no Pillow

A presença de um canal alfa por si só não garante contornos limpos: halos claros ou escuros e ruídos semitransparentes ainda podem permanecer ao redor do objeto.

Uma verificação básica do arquivo envolve:

1. Confirmar o modo RGBA esperado para PNGs transparentes.
2. Avaliar casos extremos: o arquivo deve conter tanto pixels visíveis quanto áreas transparentes (a imagem não deve ser completamente transparente nem inteiramente opaca).
3. Fazer a composição sobre fundos contrastantes, claro e escuro, para avaliar visualmente a nitidez dos contornos.

Aqui está um script compacto de verificação utilizando o Pillow:

from PIL import Image

def verify_and_composite(image_path: str):
    with Image.open(image_path) as img:
        # Verifica o modo RGBA esperado
        if img.mode != "RGBA":
            print("Erro: a imagem não está no modo RGBA.")
            return

        # Verifica a presença de pixels transparentes e visíveis
        alpha = img.getchannel("A")
        min_alpha, max_alpha = alpha.getextrema()

        if max_alpha == 0:
            print("Aviso: a imagem é totalmente transparente.")
            return
        if min_alpha == 255:
            print("Aviso: a imagem é totalmente opaca.")
            return

        # Sobreposição em fundo claro (para detectar bordas escuras)
        bg_light = Image.new("RGBA", img.size, (255, 255, 255, 255))
        Image.alpha_composite(bg_light, img).convert("RGB").save("preview_light.png")

        # Sobreposição em fundo escuro (para detectar halos brancos)
        bg_dark = Image.new("RGBA", img.size, (17, 24, 39, 255))
        Image.alpha_composite(bg_dark, img).convert("RGB").save("preview_dark.png")

As prévias geradas permitem avaliar rapidamente as bordas do asset: o contorno deve se integrar de forma suave tanto em superfícies claras quanto escuras, sem apresentar halos (fringing) ou fundos embutidos.

---

Recursos oficiais

• OpenAI Image Generation Guide
• OpenAI Image Prompting Guide