Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Redigera befintliga bilder (inpainting, outpainting)

Lektion 3 av 12 Uppdaterad 2 november 2026 Utvecklare
På denna sida
  1. Redigera befintliga bilder
  2. Hur masken fungerar
  3. Inpainting: Ersätt ett element
  4. Outpainting: Utöka bilden
  5. Iterativ redigering
  6. Viktiga punkter

Uppdaterat 2 november 2026 — Bildmodeller. gpt-image-1, modellen som denna kurs ursprungligen skrevs för, avvecklades den 23 oktober 2026. Dessutom kommer gpt-image-1.5, gpt-image-1-mini och chatgpt-image-latest att tas ur bruk den 1 december 2026. Exemplen använder nu gpt-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ällningarna xhigh och max. GPT Image-modeller returnerar alltid bilder i base64: parametern response_format som 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.