Redigera befintliga bilder (inpainting, outpainting)
På denna sida
Uppdaterat 2 november 2026 — Bildmodeller.
gpt-image-1, modellen som denna kurs ursprungligen skrevs för, avvecklades den 23 oktober 2026. Dessutom kommergpt-image-1.5,gpt-image-1-miniochchatgpt-image-latestatt tas ur bruk den 1 december 2026. Exemplen använder nugpt-image-2.5-sunburst, som erbjuder högsta precision vid redigering;gpt-image-2.5-flareär snabbare för generell generering. Båda modellerna stöder även kvalitetsinställningarnaxhighochmax. GPT Image-modeller returnerar alltid bilder i base64: parameternresponse_formatsom användes av äldre DALL·E-modeller accepteras inte längre och har tagits bort från koden. Källa: Image generation (OpenAI).
Redigera befintliga bilder
Metoden client.images.edit() modifierar en befintlig bild med hjälp av en mask för att definiera området som ska genereras om. Detta leder till två distinkta användningsfall, som är värda att namnge exakt eftersom de kräver olika typer av masker. Inpainting fyller i eller ersätter ett inre område – du kan byta ut himlen i ett landskap, skärmen på en dator eller färgen på en vägg. Outpainting, å andra sidan, utökar bilden bortom dess ursprungliga kanter, till exempel genom att göra ett kvadratiskt porträtt till ett panoramabanner.
Hur masken fungerar
Masken är en PNG-bild med samma dimensioner som källbilden. Transparenta områden (alfa = 0) indikerar var modellen ska generera nytt innehåll; opakta områden förblir orörda. Denna konvention kan kännas kontraintuitiv till en början: du vill naturligtvis “måla” det du vill ändra, men du måste egentligen klippa ut ett hål i masken istället. Själva API-anropet förblir enkelt och kräver endast de två filerna samt en beskrivning av vad som ska visas.
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))
Du behöver inget grafikprogram för att skapa denna mask. Pillow kan generera en på bara några rader: börja med ett helt opakt lager som matchar källbildens dimensioner och rita sedan formen du vill göra transparent. Skriptet nedan skapar ett rektangulärt fönster i mitten av bilden.
from PIL import Image, ImageDraw
# Läs in källbilden för att hämta dess dimensioner
source = Image.open("desk_photo.png")
width, height = source.size
# Skapa en helt opakt mask (svart)
mask = Image.new("RGBA", (width, height), (0, 0, 0, 255))
draw = ImageDraw.Draw(mask)
# Rita ett transparent område (området som ska redigeras)
# Rektangel i bildens mitt
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"Mask skapad: {width}x{height}, redigerbart område i mitten")
Inpainting: Ersätt ett element
När du upprepar denna operation är det meningsfullt att kapsla in skapandet av masken och API-anropet i en enda funktion, parametriserad efter regionen som ska modifieras. Prompten bör då endast beskriva innehållet som förväntas inom det maskerade området, aldrig resten av bilden. Exemplet nedan tillämpar denna funktion på ett landskapsfoto och modifierar endast de övre 400 pixlarna – himlen – för att ge den en stormig atmosfär.
from openai import OpenAI
from PIL import Image, ImageDraw
import base64
client = OpenAI()
def inpaint_region(image_path, region, prompt, output_path):
"""
Ersätt en rektangulär region i en bild.
region: tupel (x1, y1, x2, y2) i pixlar
"""
# Skapa masken
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")
# Anropa API:t
response = client.images.edit(
model="gpt-image-2.5-sunburst",
image=open(image_path, "rb"),
mask=open("temp_mask.png", "rb"),
prompt=prompt
)
# Spara resultatet
with open(output_path, "wb") as f:
f.write(base64.b64decode(response.data[0].b64_json))
print(f"Redigerad bild sparad: {output_path}")
# Exempel: Byt ut himlen i ett landskapsfoto
inpaint_region(
image_path="landscape.png",
region=(0, 0, 1024, 400), # Övre delen = himlen
prompt="Dramatic sky with purple storm clouds at sunset",
output_path="landscape_sky_edited.png"
)
Outpainting: Utöka bilden
Att förstorar en bild kräver ett extra steg eftersom API:t inte kan generera innehåll “bredvid” en fil direkt. Du måste först skapa en större duk, klistra in originalet på den och tillhandahålla en mask som skyddar exakt det område som originalet upptar. Hela logiken bygger på att beräkna de nya dimensionerna och inklistringspositionen baserat på den önskade riktningen.
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):
"""
Utöka en bild i en given riktning.
direction: 'right', 'bottom', 'left', 'top'
extra_pixels: antal pixlar att lägga till
"""
source = Image.open(image_path).convert("RGBA")
w, h = source.size
# Beräkna nya dimensioner
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)
# Skapa den utökade duken (transparent = område att generera)
extended = Image.new("RGBA", new_size, (0, 0, 0, 0))
extended.paste(source, paste_pos)
# Masken: transparent överallt utom där originalbilden placeras
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)
# Spara temporärt
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"Utökad bild sparad: {output_path}")
# Utöka ett porträtt åt höger
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"
)
Lägg märke till formuleringen i prompten för utökningen: “natural continuation of the scene, same lighting and background”. Vid outpainting beskriver du inte ett nytt motiv; du ber modellen att utöka det den redan ser. En alltför kreativ prompt skulle producera en synlig söm mellan originalet och det tillagda området.
Iterativ redigering
Inget hindrar dig från att kedja flera redigeringar på samma bild, där varje utdata blir indata för nästa steg. Detta är det mest tillförlitliga sättet att bygga en komplex komposition: hantera bakgrunden först, sedan förgrunden, med en dedikerad mask för varje genomgång, istället för att hoppas på att en enda prompt ska fixa allt på en gång.
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
# Steg 1: Modifiera bakgrunden
step1 = edit_step(
"scene.png", "mask_background.png",
"Lush tropical forest background",
"scene_step1.png"
)
# Steg 2: Lägg till ett element i förgrunden
step2 = edit_step(
step1, "mask_foreground.png",
"A colorful macaw parrot perched on a branch",
"scene_step2.png"
)
print(f"Slutresultat: {step2}")
Viktiga punkter
Fyra tekniska regler styr lyckade anrop. Att bryta mot någon av dem resulterar i ett omedelbart fel istället för ett försämrat resultat.
- Källbilden och masken måste ha samma dimensioner
- Båda filerna måste vara i PNG-format
- Maximal storlek per fil är 4 MB
- Masken använder alfakanalen för att definiera redigerbara områden
En empirisk observation läggs till dessa begränsningar: resultaten är mer konsekventa när det maskerade området utgör mindre än 50 % av bilden. Utöver det har modellen för lite kontext för att blandas korrekt, och du får ofta bättre resultat genom att dela upp din modifiering i två på varandra följande redigeringar.
Sätt detta i praktiken med ett foto av ditt skrivbord eller valfri bild med fri upphovsrätt: skriv ett skript som automatiskt genererar en mask över den övre fjärdedelen av bilden, ersätter det området med en stjärnhimmel och sparar resultatet lokalt.