Ir para o conteúdo principal
Português— Escolher um idioma
Menu

Controlo da qualidade, estilo e resolução

Aula 4 de 12 Atualizada a 2 de novembro de 2026 Programador
Nesta página
  1. Controlo da qualidade, estilo e resolução
  2. Níveis de qualidade
  3. Resoluções disponíveis
  4. Controlo do estilo através do seu prompt
  5. Função utilitária para geração
  6. Escolha a combinação certa

Atualizado em 2 de novembro de 2026 — Modelos de imagem. O gpt-image-1, modelo para o qual este curso foi originalmente escrito, foi descontinuado a 23 de outubro de 2026. Além disso, o gpt-image-1.5, o gpt-image-1-mini e o chatgpt-image-latest serão retirados de serviço a 1 de dezembro de 2026. Os exemplos agora utilizam o gpt-image-2.5-sunburst, que oferece a maior precisão para edição; o gpt-image-2.5-flare é mais rápido para geração padrão. Ambos os modelos suportam agora os níveis de qualidade xhigh e max. Os modelos GPT Image devolvem sempre as imagens em formato base64: o parâmetro response_format, utilizado pelos modelos DALL·E mais antigos, já não é aceite e foi removido do código. Fonte: Geração de imagens (OpenAI).

Controlo da qualidade, estilo e resolução

O GPT Image disponibiliza várias alavancas para ajustar o seu resultado, mas nem todas funcionam da mesma forma. A qualidade e a resolução são parâmetros explícitos da API que afetam o custo e o tempo de geração. O estilo, no entanto, é controlado inteiramente através do seu prompt. Compreender esta distinção evita que procure opções inexistentes e ajuda-o a otimizar a relação qualidade-custo em cada geração.

Níveis de qualidade

O parâmetro quality impacta diretamente o nível de detalhe e o tempo de geração. A melhor forma de observar a diferença é testá-lo num tema exigente — como uma natureza-morta com iluminação de Rembrandt, onde gradientes e texturas são críticos — e não num gráfico plano, onde as diferenças seriam invisíveis.

import base64
from openai import OpenAI

client = OpenAI()

qualities = ["low", "medium", "high"]

for q in qualities:
    response = client.images.generate(
        model="gpt-image-2.5-sunburst",
        prompt="Still life with exotic fruits on a marble table, Rembrandt lighting",
        size="1024x1024",
        quality=q
    )
    with open(f"quality_{q}.png", "wb") as f:
        f.write(base64.b64decode(response.data[0].b64_json))
    print(f"Quality {q}: quality_{q}.png")
QualidadeDetalhesTempoCustoUtilização Recomendada
lowBásicoRápidoEconómicoRascunhos, testes, prototipagem
mediumBomModeradoIntermédioRedes sociais, apresentações
highMáximoMais lentoPremiumImpressão, publicidade, portefólios

Resoluções disponíveis

Estão disponíveis três proporções de imagem, cada uma adaptada a casos de uso específicos: quadrado 1024×1024 para redes sociais e avatares, retrato 1024×1536 para stories, cartazes e ecrãs móveis, e paisagem 1536×1024 para banners, cabeçalhos e apresentações. Gere sempre diretamente no formato de destino. Recortar posteriormente desperdiça pixels pelos quais pagou e perturba a composição que o modelo construiu para esse enquadramento específico.

import base64
from openai import OpenAI

client = OpenAI()

resolutions = {
    "1024x1024": "Quadrado — ideal para redes sociais e avatares",
    "1024x1536": "Retrato — stories, cartazes, telemóvel",
    "1536x1024": "Paisagem — banners, cabeçalhos, apresentações",
}

for size, description in resolutions.items():
    response = client.images.generate(
        model="gpt-image-2.5-sunburst",
        prompt="Panoramic view of a futuristic city at dusk, neon lights and skyscrapers",
        size=size,
        quality="medium"
    )
    with open(f"city_{size}.png", "wb") as f:
        f.write(base64.b64decode(response.data[0].b64_json))
    print(f"{size} ({description}) → city_{size}.png")

Controlo do estilo através do seu prompt

O estilo não é um parâmetro explícito da API; controla-o inteiramente através do seu prompt. A técnica mais fiável é especificar um meio preciso com o seu próprio vocabulário. “Fotografia profissional, Nikon D850, f/2.8” não solicita apenas uma foto — exige uma profundidade de campo e uma renderização ótica específicas. “Arte pixelada retro de 16 bits, paleta limitada” impõe uma restrição de resolução que o modelo respeitará. O ciclo abaixo aplica cinco meios diferentes ao mesmo tema, tornando as diferenças imediatamente visíveis.

import base64
mediums = [
    "professional photography, Nikon D850, f/2.8",
    "oil painting on canvas, impressionist style",
    "flat design vector illustration, pastel colors",
    "architectural technical drawing, cross-section view",
    "retro 16-bit pixel art, limited palette",
]

for medium in mediums:
    prompt = f"A typical Parisian café with outdoor seating, {medium}"
    response = client.images.generate(
        model="gpt-image-2.5-sunburst",
        prompt=prompt,
        size="1024x1024",
        quality="medium"
    )
    filename = f"cafe_{mediums.index(medium) + 1}.png"
    with open(filename, "wb") as f:
        f.write(base64.b64decode(response.data[0].b64_json))
    print(f"{medium[:40]}... → {filename}")

A iluminação é a sua segunda alavanca e, frequentemente, a mais poderosa: pode transformar radicalmente a mesma cena. Um retrato de uma artesã de cerâmica na sua oficina torna-se uma imagem documental sóbria sob iluminação de estúdio de três pontos, uma imagem publicitária com luz da hora dourada ou um cartaz de cinema em claro-escuro ao estilo Caravaggio. O tema não mudou uma palavra; apenas a atmosfera se alterou.

import base64
lightings = [
    "three-point studio lighting, neutral white background",
    "natural golden hour light",
    "cyberpunk neon lighting, pink and blue",
    "dramatic Caravaggio-style chiaroscuro",
    "diffuse rainy day light, gray tones",
]

for lighting in lightings:
    prompt = f"Portrait of a ceramic artisan in her workshop, {lighting}"
    response = client.images.generate(
        model="gpt-image-2.5-sunburst",
        prompt=prompt,
        size="1024x1536",
        quality="high"
    )
    filename = f"artisan_{lightings.index(lighting) + 1}.png"
    with open(filename, "wb") as f:
        f.write(base64.b64decode(response.data[0].b64_json))
    print(f"Lighting: {lighting} → {filename}")

Função utilitária para geração

Repetir as mesmas seis linhas em cada chamada torna-se rapidamente tedioso e propenso a erros. Encapsule as suas preferências padrão numa função reutilizável que também trate do armazenamento em disco e da sufixação de ficheiros quando solicitar múltiplas imagens.

from openai import OpenAI
import base64
from pathlib import Path

client = OpenAI()

def generate_image(
    prompt: str,
    output_path: str,
    size: str = "1024x1024",
    quality: str = "medium",
    n: int = 1
) -> list[str]:
    """
    Gera uma ou mais imagens e guarda-as localmente.
    Devolve uma lista dos caminhos dos ficheiros criados.
    """
    response = client.images.generate(
        model="gpt-image-2.5-sunburst",
        prompt=prompt,
        n=n,
        size=size,
        quality=quality,
    )

    paths = []
    for i, image in enumerate(response.data):
        if n > 1:
            path = Path(output_path).stem + f"_{i+1}" + Path(output_path).suffix
        else:
            path = output_path

        data = base64.b64decode(image.b64_json)
        with open(path, "wb") as f:
            f.write(data)
        paths.append(path)
        print(f"Saved: {path}")

    return paths


# Utilização
generate_image(
    prompt="Premium packaging for matcha tea, minimalist Japanese design",
    output_path="matcha_packaging.png",
    size="1024x1024",
    quality="high"
)

Escolha a combinação certa

Você decide ambos os parâmetros em conjunto, com base no seu meio de destino. A tabela abaixo resume os cenários mais comuns.

ContextoResoluçãoQualidade
Prototipagem rápida1024×1024low
Publicação Instagram / LinkedIn1024×1024medium
Story vertical / Reel1024×1536medium
Banner web / cabeçalho1536×1024medium
Cartaz de impressão A3+1024×1536high
Portefólio criativo / livro1024×1024high
Teste em lote de prompts1024×1024low

Em produção, não copie manualmente esta tabela para todos os scripts. Traduza-a em lógica de configuração e deixe o seu código escolher com base no contexto declarado. Obtém uma única fonte de verdade e, se mais tarde decidir que as suas publicações nas redes sociais devem usar qualidade high, basta alterar uma linha.

def generate_for_context(prompt: str, context: str, output: str):
    """Adapta automaticamente a qualidade e a resolução ao contexto."""
    configs = {
        "prototype": {"size": "1024x1024", "quality": "low"},
        "social_media": {"size": "1024x1024", "quality": "medium"},
        "story": {"size": "1024x1536", "quality": "medium"},
        "banner": {"size": "1536x1024", "quality": "medium"},
        "print": {"size": "1024x1536", "quality": "high"},
    }

    config = configs.get(context, configs["social_media"])

    return generate_image(
        prompt=prompt,
        output_path=output,
        **config
    )


# Gerar a mesma imagem para diferentes suportes
generate_for_context(
    "Corsen AI logo on dark background, premium tech style",
    "social_media",
    "logo_social.png"
)

Para construir o seu próprio julgamento sobre estas definições, gere você mesmo a matriz completa: escreva um script que receba um único prompt e produza todas as nove combinações de qualidade × resolução, guarde cada ficheiro com um nome explícito como image_low_1024x1024.png e apresente uma tabela resumo. Em breve saberá, a olho nu, quando a qualidade medium é suficiente.