Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Bestaande afbeeldingen bewerken (inpainting, outpainting)

Les 3 van 12 Bijgewerkt op 2 november 2026 Ontwikkelaar
Op deze pagina
  1. Bestaande afbeeldingen bewerken
  2. Hoe het masker werkt
  3. Inpainting: Een element vervangen
  4. Outpainting: De afbeelding uitbreiden
  5. Iteratief bewerken
  6. Belangrijkste beperkingen

Bijgewerkt op 2 november 2026 — Afbeeldingsmodellen. gpt-image-1, het model waarvoor deze cursus oorspronkelijk is geschreven, is verouderd op 23 oktober 2026. Bovendien worden gpt-image-1.5, gpt-image-1-mini en chatgpt-image-latest buiten gebruik gesteld op 1 december 2026. De voorbeelden gebruiken nu gpt-image-2.5-sunburst, dat de hoogste precisie biedt voor bewerkingen; gpt-image-2.5-flare is sneller voor algemene generatie. Beide modellen ondersteunen ook de kwaliteitsinstellingen xhigh en max. GPT Image-modellen retourneren afbeeldingen altijd in base64: de parameter response_format die door oudere DALL·E-modellen werd gebruikt, wordt niet langer geaccepteerd en is uit de code verwijderd. Bron: Image generation (OpenAI).

Bestaande afbeeldingen bewerken

De methode client.images.edit() wijzigt een bestaande afbeelding met behulp van een masker om het gebied te definiëren dat opnieuw gegenereerd moet worden. Dit leidt tot twee verschillende gebruiksscenario’s, die het waard zijn om nauwkeurig te benoemen omdat ze verschillende maskers vereisen. Inpainting vult of vervangt een binnenste gebied; u kunt bijvoorbeeld de lucht in een landschap wijzigen, het scherm op een computer aanpassen of de kleur van een muur veranderen. Outpainting daarentegen breidt de afbeelding uit voorbij de oorspronkelijke randen, zoals het omzetten van een vierkant portret in een panoramische banner.

Hoe het masker werkt

Het masker is een PNG-afbeelding met dezelfde afmetingen als de bronafbeelding. Transparante gebieden (alfa = 0) geven aan waar het model nieuwe inhoud moet genereren; ondeugzame gebieden blijven onaangetast. Deze conventie is in eerste instantie contra-intuïtief: u wilt natuurlijk “verven” wat u wilt veranderen, maar u moet eigenlijk een gat in het masker knippen. De API-oproep zelf blijft eenvoudig en vereist slechts de twee bestanden en een beschrijving van wat er moet verschijnen.

import base64
from openai import OpenAI

client = OpenAI()

response = client.images.edit(
    model="gpt-image-2.5-sunburst",
    image=open("desk_photo.png", "rb"),
    mask=open("desk_mask.png", "rb"),
    prompt="A computer screen displaying a modern analytics dashboard"
)

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

U heeft geen grafisch bewerkingsprogramma nodig om dit masker te maken. Pillow kan er in slechts een paar regels een genereren: begin met een volledig ondeugzame laag die overeenkomt met de afmetingen van de bron, en teken vervolgens de vorm die u transparant wilt maken. Het onderstaande script maakt een rechthoekig venster in het midden van de afbeelding.

from PIL import Image, ImageDraw

# Laad de bronafbeelding om de afmetingen op te halen
source = Image.open("desk_photo.png")
width, height = source.size

# Maak een volledig ondeugzaam masker (zwart)
mask = Image.new("RGBA", (width, height), (0, 0, 0, 255))
draw = ImageDraw.Draw(mask)

# Teken een transparant gebied (het te bewerken gebied)
# Rechthoek in het midden van de afbeelding
x1, y1 = width // 4, height // 4
x2, y2 = 3 * width // 4, 3 * height // 4
draw.rectangle([x1, y1, x2, y2], fill=(0, 0, 0, 0))

mask.save("desk_mask.png")
print(f"Masker gemaakt: {width}x{height}, bewerkbaar gebied in het midden")

Inpainting: Een element vervangen

Zodra u deze handeling herhaalt, is het zinvol om het maken van het masker en de API-oproep onder te brengen in één functie, geparametriseerd door het te wijzigen gebied. De prompt moet vervolgens alleen de inhoud beschrijven die binnen het gemaskeerde gebied wordt verwacht, nooit de rest van de afbeelding. Het onderstaande voorbeeld past deze functie toe op een landschapsfoto en wijzigt alleen de bovenste 400 pixels – de lucht – om deze een stormachtige sfeer te geven.

from openai import OpenAI
from PIL import Image, ImageDraw
import base64

client = OpenAI()

def inpaint_region(image_path, region, prompt, output_path):
    """
    Vervang een rechthoekig gebied in een afbeelding.
    region: tuple (x1, y1, x2, y2) in pixels
    """
    # Maak het masker
    source = Image.open(image_path)
    mask = Image.new("RGBA", source.size, (0, 0, 0, 255))
    draw = ImageDraw.Draw(mask)
    draw.rectangle(region, fill=(0, 0, 0, 0))
    mask.save("temp_mask.png")

    # Roep de API aan
    response = client.images.edit(
        model="gpt-image-2.5-sunburst",
        image=open(image_path, "rb"),
        mask=open("temp_mask.png", "rb"),
        prompt=prompt
    )

    # Sla het resultaat op
    with open(output_path, "wb") as f:
        f.write(base64.b64decode(response.data[0].b64_json))
    print(f"Bewerkte afbeelding opgeslagen: {output_path}")


# Voorbeeld: Vervang de lucht in een landschapsfoto
inpaint_region(
    image_path="landscape.png",
    region=(0, 0, 1024, 400),  # Bovenste deel = de lucht
    prompt="Dramatic sky with purple storm clouds at sunset",
    output_path="landscape_sky_edited.png"
)

Outpainting: De afbeelding uitbreiden

Het vergroten van een afbeelding vereist een extra stap, omdat de API geen inhoud direct “naast” een bestand kan genereren. U moet eerst een groter canvas maken, het origineel daarop plakken en een masker leveren dat precies het gebied beschermt dat door dat origineel wordt ingenomen. De hele logica draait om het berekenen van de nieuwe afmetingen en de plakpositie op basis van de gevraagde richting.

from openai import OpenAI
from PIL import Image
import base64
from io import BytesIO

client = OpenAI()

def outpaint(image_path, direction, extra_pixels, prompt, output_path):
    """
    Breid een afbeelding uit in een bepaalde richting.
    direction: 'right', 'bottom', 'left', 'top'
    extra_pixels: aantal toe te voegen pixels
    """
    source = Image.open(image_path).convert("RGBA")
    w, h = source.size

    # Bereken nieuwe afmetingen
    if direction == "right":
        new_size = (w + extra_pixels, h)
        paste_pos = (0, 0)
    elif direction == "bottom":
        new_size = (w, h + extra_pixels)
        paste_pos = (0, 0)
    elif direction == "left":
        new_size = (w + extra_pixels, h)
        paste_pos = (extra_pixels, 0)
    elif direction == "top":
        new_size = (w, h + extra_pixels)
        paste_pos = (0, extra_pixels)

    # Maak het uitgebreide canvas (transparant = gebied om te genereren)
    extended = Image.new("RGBA", new_size, (0, 0, 0, 0))
    extended.paste(source, paste_pos)

    # Het masker: overal transparant behalve waar de originele afbeelding is geplaatst
    mask = Image.new("RGBA", new_size, (0, 0, 0, 0))
    opaque = Image.new("RGBA", (w, h), (0, 0, 0, 255))
    mask.paste(opaque, paste_pos)

    # Tijdelijk opslaan
    extended.save("temp_extended.png")
    mask.save("temp_mask_outpaint.png")

    response = client.images.edit(
        model="gpt-image-2.5-sunburst",
        image=open("temp_extended.png", "rb"),
        mask=open("temp_mask_outpaint.png", "rb"),
        prompt=prompt
    )

    with open(output_path, "wb") as f:
        f.write(base64.b64decode(response.data[0].b64_json))
    print(f"Uitgebreide afbeelding opgeslagen: {output_path}")


# Breid een portret naar rechts uit
outpaint(
    image_path="portrait.png",
    direction="right",
    extra_pixels=512,
    prompt="Natural continuation of the scene, same lighting and background",
    output_path="portrait_extended.png"
)

Let op de formulering van de uitbreidingsprompt: “natuurlijke voortzetting van de scène, dezelfde belichting en achtergrond”. Bij outpainting beschrijft u geen nieuw onderwerp; u vraagt het model om uit te breiden wat het al ziet. Een te creatieve prompt zou een zichtbare naad tussen het origineel en het toegevoegde gebied opleveren.

Iteratief bewerken

Niets weerhoudt u ervan om meerdere bewerkingen op dezelfde afbeelding te ketenen, waarbij elke uitvoer als invoer voor de volgende stap dient. Dit is de meest betrouwbare manier om een complexe compositie op te bouwen: behandel eerst de achtergrond, dan de voorgrond, met een toegewijd masker voor elke doorgang, in plaats van te hopen dat één prompt alles in één keer oplost.

import base64
from openai import OpenAI

client = OpenAI()

def edit_step(image_path, mask_path, prompt, output_path):
    response = client.images.edit(
        model="gpt-image-2.5-sunburst",
        image=open(image_path, "rb"),
        mask=open(mask_path, "rb"),
        prompt=prompt
    )
    with open(output_path, "wb") as f:
        f.write(base64.b64decode(response.data[0].b64_json))
    return output_path

# Stap 1: Wijzig de achtergrond
step1 = edit_step(
    "scene.png", "mask_background.png",
    "Lush tropical forest background",
    "scene_step1.png"
)

# Stap 2: Voeg een element toe aan de voorgrond
step2 = edit_step(
    step1, "mask_foreground.png",
    "A colorful macaw parrot perched on a branch",
    "scene_step2.png"
)

print(f"Eindresultaat: {step2}")

Belangrijkste beperkingen

Vier technische regels bepalen het succes van de oproep. Overtreding van een daarvan resulteert in een onmiddellijke fout in plaats van een verslechterd resultaat.

  • De bronafbeelding en het masker moeten dezelfde afmetingen hebben
  • Beide bestanden moeten in PNG-formaat zijn
  • De maximale grootte per bestand is 4 MB
  • Het masker gebruikt het alfakanaal om bewerkbare gebieden te definiëren

Een empirische observatie voegt zich bij deze beperkingen: resultaten zijn consistenter wanneer het gemaskeerde gebied minder dan 50% van de afbeelding vertegenwoordigt. Daarboven heeft het model te weinig context om correct te mengen, en krijgt u vaak betere resultaten door uw wijziging in twee opeenvolgende bewerkingen te splitsen.

Pas dit in de praktijk toe met een foto van uw bureau of een royalty-vrije afbeelding: schrijf een script dat automatisch een masker genereert over het bovenste kwart van de afbeelding, dat gebied vervangt door een sterrenhemel en het resultaat lokaal opslaat.