Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Kombiniraj generiranje slika s drugim API alatima

Lekcija 10 od 12 Ažurirano 2. studenoga 2026. Programer
Na ovoj stranici
  1. Kombiniraj generiranje slika s drugim API alatima
  2. Neka jezični model napiše prompt
  3. Ilustriraj članak od početka do kraja
  4. Opiši sliku da bi je drugačije regenerirao
  5. Obradi velike volumene u serijama (batch)
  6. Objavi izravno u pohranu
  7. Ključne točke

Ažuriranje 2. studenoga 2026. — Modeli slika. gpt-image-1, model za koji je ovaj tečaj izvorno napisan, ukinut je 23. listopada 2026.. gpt-image-1.5, gpt-image-1-mini i chatgpt-image-latest bit će povučeni 1. prosinca 2026.. Primjeri sada koriste gpt-image-2.5-sunburst, koji nudi najveću preciznost za uređivanje; gpt-image-2.5-flare je brži za standardno generiranje. Oba modela također podržavaju postavke kvalitete xhigh i max. GPT Image modeli uvijek vraćaju slike u base64 formatu: parametar response_format iz starijih DALL·E modela nije podržan i uklonjen je iz koda. Izvor: Image generation (OpenAI).

Kombiniraj generiranje slika s drugim API alatima

Sama po sebi, generacija slika je zanatski alat: napišeš prompt, dobiješ datoteku. Njezina prava snaga dolazi do izražaja kada postane korak u automatiziranom lancu — jezični model koji piše prompt, vizualna analiza koja opisuje referentnu sliku ili pohrana koja objavljuje rezultat. Ova lekcija pokazuje ti kako spojiti ove dijelove.

Neka jezični model napiše prompt

Tvoji korisnici ili kolege ne pišu vizualne prompte; oni pišu kratke opise (briefove). „Treba mi slika za članak o umjetnoj inteligenciji u zdravstvu, futuristička, ali ljudska“ ne sadrži kompoziciju, osvjetljenje niti paletu boja. Umjesto da od njih tražiš da nauče vokabular iz prethodne lekcije, umetni jezični model koji će obaviti prijevod. Dodijeli mu ulogu umjetničkog direktora u sistemskoj poruci i zahtijevaj da proizvede specifične slojeve prompta, uz stroge upute da ne ispiše ništa drugo. Inače ćeš dobiti ljubazno objašnjenje koje ćeš potom morati poslati GPT Imageu.

from openai import OpenAI
import base64

client = OpenAI()

def text_to_image(brief: str, output: str):
    """
    Dvostepeni pipeline:
    1. LLM generira optimalni vizualni prompt
    2. GPT Image stvara sliku
    """
    # Korak 1: Generiraj vizualni prompt pomoću LLM-a
    completion = client.chat.completions.create(
        model="gpt-5.6-luna",
        messages=[
            {
                "role": "system",
                "content": (
                    "You are an expert art director. "
                    "Based on a brief, generate a detailed prompt for an "
                    "image generation model. Include: subject, composition, lighting, "
                    "style, perspective, color palette. "
                    "Respond only with the prompt, no explanation."
                )
            },
            {"role": "user", "content": brief}
        ]
    )

    visual_prompt = completion.choices[0].message.content
    print(f"Generated prompt: {visual_prompt[:100]}...")

    # Korak 2: Generiraj sliku
    response = client.images.generate(
        model="gpt-image-2.5-sunburst",
        prompt=visual_prompt,
        size="1536x1024",
        quality="high",
    )

    data = base64.b64decode(response.data[0].b64_json)
    with open(output, "wb") as f:
        f.write(data)
    print(f"Image generated: {output}")
    return visual_prompt


prompt = text_to_image(
    "I need an image for an article on artificial intelligence "
    "in healthcare. Futuristic but human.",
    "ai_health.png"
)

Ilustriraj članak od početka do kraja

Tematski članak treba naslovnu sliku i po jednu ilustraciju za svaki odjeljak. Te slike moraju izgledati kohezivno, a da pritom nisu identične. Funkcija illustrate_article primjenjuje ovu logiku ponovnim ubacivanjem stila u svaki prompt i ponavljanjem naslova članka svaki put, čime cijeli skup dobiva tematsko jedinstvo. Dva detalja koja štede troškove zaslužuju pažnju: naslovnica se generira u high kvaliteti jer je svi vide i često se dijeli, dok ilustracije odjeljaka ostaju na medium jer se prikazuju manje i niže na stranici. Za pet odjeljaka u ovom primjeru o AI-u u regrutiranju, ovaj kompromis smanjuje račun, a da čitatelj to ni ne primijeti.

from openai import OpenAI
import base64
import json

client = OpenAI()

def illustrate_article(title: str, sections: list[str], style: str, output_dir: str = "."):
    """
    Generira naslovnu ilustraciju + po jednu za svaki odjeljak.
    """
    results = []

    # Naslovna slika
    header_prompt = (
        f"Cover image for an article titled \"{title}\", "
        f"{style} style, panoramic composition, "
        "no text in the image, professional"
    )

    response = client.images.generate(
        model="gpt-image-2.5-sunburst",
        prompt=header_prompt,
        size="1536x1024",
        quality="high",
    )

    path = f"{output_dir}/header.png"
    data = base64.b64decode(response.data[0].b64_json)
    with open(path, "wb") as f:
        f.write(data)
    results.append({"type": "header", "path": path})
    print(f"Header: {path}")

    # Ilustracije odjeljaka
    for i, section in enumerate(sections):
        section_prompt = (
            f"Illustration for the section \"{section}\" "
            f"of an article on \"{title}\", "
            f"{style} style, rectangular format, "
            "conceptual illustration without text"
        )

        response = client.images.generate(
            model="gpt-image-2.5-sunburst",
            prompt=section_prompt,
            size="1536x1024",
            quality="medium",
        )

        path = f"{output_dir}/section_{i+1}.png"
        data = base64.b64decode(response.data[0].b64_json)
        with open(path, "wb") as f:
            f.write(data)
        results.append({"type": f"section_{i+1}", "section": section, "path": path})
        print(f"Section {i+1} ({section[:30]}...) : {path}")

    return results


illustrate_article(
    title="5 Ways AI Is Transforming Recruitment",
    sections=[
        "Automatic CV Screening",
        "AI-Analyzed Video Interviews",
        "Smart Candidate-Job Matching",
        "Reducing Recruitment Bias",
        "Personalized Onboarding",
    ],
    style="3D isometric illustration, blue and violet tones",
    output_dir="."
)

Opiši sliku da bi je drugačije regenerirao

Kako doći do zimske verzije ljetnog pejzaža kada imaš samo datoteku, bez maske i bez alata za uređivanje? Kroz jezik. Modelova vizija analizira sliku i proizvodi opis dovoljno precizan da posluži kao prompt za rekonstrukciju — subjekt, kompozicija, osvjetljenje, boje, stil, perspektiva, raspoloženje. Zatim tom opisu dodaješ svoju uputu za izmjenu. Model za generiranje prima kompletan tekstualni prompt u kojem je promijenjena samo godišnja doba, a ti dobivaš sliku koherentnu s originalom, umjesto nečega nepovezanog. Ovo je također najpouzdaniji način za reproduciranje vizualnog identiteta referentne slike koju ne možeš izravno uređivati.

from openai import OpenAI
import base64

client = OpenAI()

def analyze_and_vary(image_path: str, instruction: str, output: str):
    """
    1. Analizira sliku pomoću GPT Visiona
    2. Generira varijantu na temelju analize
    """
    # Korak 1: Analiziraj sliku
    with open(image_path, "rb") as f:
        image_b64 = base64.b64encode(f.read()).decode()

    analysis = client.chat.completions.create(
        model="gpt-5.6-luna",
        messages=[
            {
                "role": "user",
                "content": [
                    {
                        "type": "text",
                        "text": (
                            "Describe this image in detail so an image "
                            "generation model can reproduce it faithfully. "
                            "Include: subject, composition, lighting, colors, style, "
                            "perspective, mood. Be very precise."
                        )
                    },
                    {
                        "type": "image_url",
                        "image_url": {
                            "url": f"data:image/png;base64,{image_b64}"
                        }
                    }
                ]
            }
        ]
    )

    description = analysis.choices[0].message.content
    print(f"Analysis: {description[:150]}...")

    # Korak 2: Generiraj modificiranu varijantu
    variant_prompt = f"{description}. Requested modification: {instruction}"

    response = client.images.generate(
        model="gpt-image-2.5-sunburst",
        prompt=variant_prompt,
        size="1024x1024",
        quality="high",
    )

    data = base64.b64decode(response.data[0].b64_json)
    with open(output, "wb") as f:
        f.write(data)
    print(f"Variant generated: {output}")


analyze_and_vary(
    "original_landscape.png",
    "Change the season from summer to winter, with snow on roofs and trees",
    "winter_landscape.png"
)

Obradi velike volumene u serijama (batch)

Generiranje pet vizuala proizvoda u nizu traje minute; generiranje petsto uzastopno traje cijelu noć i puca pri prvoj mrežnoj smetnji. Postavka u nastavku rješava oba problema. Svaki zadatak je samostalni rječnik koji nosi svoj ID, prompt, izlaznu datoteku i postavke. Funkcija worker omata poziv u try blok koji vraća status umjesto da sruši cijelu seriju: odbijeno generiranje više ne povlači dolje ostalih četiristo devedeset i devet. ThreadPoolExecutor zatim paralelizira izvršavanje, ali s namjerno niskim max_workers — tri u ovom primjeru — jer usko grlo nije tvoje računalo, već API kvote. Završno izvješće broji uspjehe i greške kako bi znao što ponoviti.

from openai import OpenAI
import base64
import json
import time
from concurrent.futures import ThreadPoolExecutor, as_completed

client = OpenAI()

def generate_one_image(task: dict) -> dict:
    """Generira jednu sliku iz zadatka."""
    try:
        response = client.images.generate(
            model="gpt-image-2.5-sunburst",
            prompt=task["prompt"],
            size=task.get("size", "1024x1024"),
            quality=task.get("quality", "medium"),
        )

        data = base64.b64decode(response.data[0].b64_json)
        with open(task["output"], "wb") as f:
            f.write(data)

        return {"id": task["id"], "status": "ok", "path": task["output"]}

    except Exception as e:
        return {"id": task["id"], "status": "error", "error": str(e)}


def batch_generation(tasks: list[dict], max_parallel: int = 3):
    """Izvršava seriju generiranja s kontroliranom paralelizacijom."""
    results = []

    with ThreadPoolExecutor(max_workers=max_parallel) as executor:
        futures = {
            executor.submit(generate_one_image, task): task
            for task in tasks
        }

        for future in as_completed(futures):
            result = future.result()
            results.append(result)
            status = result["status"]
            print(f"  [{status}] {result['id']}")

    # Izvješće
    ok = sum(1 for r in results if r["status"] == "ok")
    errors = sum(1 for r in results if r["status"] == "error")
    print(f"\nFinished: {ok} ok, {errors} errors out of {len(tasks)} tasks")

    return results


# Definiraj seriju zadataka
tasks = [
    {
        "id": f"product_{i}",
        "prompt": f"E-commerce product photo: {product}, white background, studio",
        "output": f"batch_product_{i}.png",
        "quality": "high"
    }
    for i, product in enumerate([
        "rose gold watch",
        "aviator sunglasses",
        "braided leather bracelet",
        "solitaire diamond ring",
        "cultured pearl necklace",
    ])
]

results = batch_generation(tasks, max_parallel=3)

Objavi izravno u pohranu

Zapisivanje PNG-a na disk stroja koji pokreće skriptu ima smisla samo u razvoju. U produkciji, slika mora završiti tamo gdje će je tvoja stranica dohvatiti, a zaobilaženje lokalnog datotečnog sustava postaje nepotrebna točka kvara. Format b64_json dobro odgovara ovom uklanjanju: dekodirani bajtovi omotani su u BytesIO objekt i gurnuti izravno u spremnik (bucket), s eksplicitnim ContentType — bez kojeg bi preglednici nudili preuzimanje umjesto prikaza slike. Funkcija vraća javni URL, što je ono što tvom CMS-u zapravo treba.

from openai import OpenAI
import base64
import boto3
from io import BytesIO

client = OpenAI()

def generate_and_store_s3(prompt: str, bucket: str, key: str):
    """Generira sliku i učitava je izravno na S3."""
    response = client.images.generate(
        model="gpt-image-2.5-sunburst",
        prompt=prompt,
        size="1024x1024",
        quality="high",
    )

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

    s3 = boto3.client("s3")
    s3.upload_fileobj(
        BytesIO(image_data),
        bucket,
        key,
        ExtraArgs={"ContentType": "image/png"}
    )

    url = f"https://{bucket}.s3.amazonaws.com/{key}"
    print(f"Image stored on S3: {url}")
    return url


# Primjer
url = generate_and_store_s3(
    "Mobile app icon: open book with stars, flat design",
    "my-image-bucket",
    "generated/app_icon_v1.png"
)

Ključne točke

Pet pipelineova u ovoj lekciji dijele istu higijenu izgradnje. Svaki korak radi jednu stvar, što ti omogućuje zamjenu pisanja prompta ili pohrane bez diranja ostatka. Svaki korak rukuje vlastitim greškama; inače, odbijanje moderacije usred serije ruši cijeli lanac — točno je ono što try u generate_one_image sprječava. Paralelizam ostaje prigušen kako bi se poštovala ograničenja brzine (rate limits), a po ovom pitanju, oprez košta manje od oporavka nakon privremene zabrane.

Preostaju dvije manje vidljive, ali jednako odlučujuće navike. Bilježi prompte koji su zapravo poslani, posebno kada ih piše jezični model: bez ovog zapisa, slika koju voliš postaje nereproducibilna pri drugom pokretanju. I keširaj rezultate kad god se isti prompt može ponoviti, što sljedeća lekcija formalizira u kompletan sustav.

Sada sastavi svoj vlastiti puni lanac: uzima naslov članka kao ulaz, traži od jezičnog modela tri opisa relevantnih vizuala, generira te tri slike paralelno i proizvodi sažeti JSON koji povezuje svaki prompt s njegovom datotekom. Tada ćeš imati sve potrebno za ilustriranje cijelog bloga bez ručne intervencije.