Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Olemasolevate piltide muutmine (sisse- ja väljamaalimine)

Õppetund 3 / 12 Värskendatud 2. november 2026 Arendajatele
Sellel lehel
  1. Olemasolevate piltide muutmine
  2. Kuidas mask töötab
  3. Sissemaalimine: Elemendi asendamine
  4. Väljamaalimine: Pildi laiendamine
  5. Iteratiivne redigeerimine
  6. Peamised piirangud

Uuendatud 2. novembril 2026 – Pildimudelid. gpt-image-1, mudel, mille jaoks see kursus algselt kirjutati, tunnistati aegunuks 23. oktoobril 2026. Lisaks lõpetatakse gpt-image-1.5, gpt-image-1-mini ja chatgpt-image-latest kasutamine 1. detsembril 2026. Näited kasutavad nüüd mudelit gpt-image-2.5-sunburst, mis pakub redigeerimisel suurimat täpsust; gpt-image-2.5-flare on üldiseks genereerimiseks kiirem. Mõlemad mudelid toetavad ka kvaliteedisätteid xhigh ja max. GPT Image mudelid tagastavad pildid alati base64-formaadis: vanemate DALL·E mudelite kasutatud parameeter response_format ei ole enam aktsepteeritud ja on koodist eemaldatud. Allikas: Pildigeneratsioon (OpenAI).

Olemasolevate piltide muutmine

Meetod client.images.edit() muudab olemasolevat pilti, kasutades maski, et määratleda ala, mida tuleb uuesti genereerida. See viib kahe erineva kasutusjuhtumini, mida tasub täpselt nimetada, kuna need nõuavad erinevaid maske. Sissemaalimine (inpainting) täidab või asendab sisemist ala – võid muuta maastikul taevast, arvuti ekraani või seina värvi. Väljamaalimine (outpainting) seevastu laiendab pilti väljapoole selle algseid piire, näiteks muutes ruudukujulise portree panoraamseks bänneriks.

Kuidas mask töötab

Mask on PNG-pilt, mille mõõtmed on samad kui lähtepildil. Läbipaistvad alad (alfa = 0) näitavad, kuhu mudel peaks uut sisu looma; läbipaistmatud alad jäävad puutumata. See reegel on esmapilgul vastuoluline: loomulikult tahad „värvida“ seda, mida soovid muuta, kuid tegelikult pead maski hoopis augu lõikama. API väljakutse ise jääb lihtsaks, nõudes vaid kahte faili ja kirjeldust sellest, mis ilmuma peaks.

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))

Selle maski loomiseks ei vaja sa graafikatoimetajat. Pillow suudab selle genereerida vaid mõne reaga: alusta täielikult läbipaistmatu kihiga, mis vastab lähtepildi mõõtmetele, ja joonista seejärel kuju, mida soovid läbipaistvaks muuta. Alltoodud skript loob pildi keskele ristkülikukujulise akna.

from PIL import Image, ImageDraw

# Laadi lähtepilt selle mõõtmete saamiseks
source = Image.open("desk_photo.png")
width, height = source.size

# Loo täielikult läbipaistmatu mask (must)
mask = Image.new("RGBA", (width, height), (0, 0, 0, 255))
draw = ImageDraw.Draw(mask)

# Joonista läbipaistev ala (ala, mida muuta)
# Ristkülik pildi keskel
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 loodud: {width}x{height}, muudetav ala keskel")

Sissemaalimine: Elemendi asendamine

Kui seda toimingut kordad, on mõttekas kapseldada maski loomine ja API väljakutse ühte funktsiooni, mis on parametriseeritud muudetava piirkonnaga. Prompt peaks seejärel kirjeldama ainult maskitud alal oodatavat sisu, mitte kunagi ülejäänud pilti. Alltoodud näide rakendab seda funktsiooni maastikufotole, muutes ainult ülemisi 400 pikslit – taevast –, et anda sellele tormine atmosfäär.

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

client = OpenAI()

def inpaint_region(image_path, region, prompt, output_path):
    """
    Asenda pildis ristkülikukujuline piirkond.
    region: tuple (x1, y1, x2, y2) pikslites
    """
    # Loo mask
    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")

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

    # Salvesta tulemus
    with open(output_path, "wb") as f:
        f.write(base64.b64decode(response.data[0].b64_json))
    print(f"Muudetud pilt salvestatud: {output_path}")


# Näide: Asenda taevamaastiku fotol taevas
inpaint_region(
    image_path="landscape.png",
    region=(0, 0, 1024, 400),  # Ülemine osa = taevas
    prompt="Dramatic sky with purple storm clouds at sunset",
    output_path="landscape_sky_edited.png"
)

Väljamaalimine: Pildi laiendamine

Pildi suurendamine nõuab lisasammu, kuna API ei saa genereerida sisu otse faili „kõrvale“. Pead esmalt looma suurema lõuendi, kleepima sellele originaali ja pakkuma maski, mis kaitseb täpselt seda ala, mille originaal hõivab. Kogu loogika seisneb uute mõõtmete ja kleepimisasukoha arvutamises soovitud suuna põhjal.

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):
    """
    Laienda pilti antud suunas.
    direction: 'right', 'bottom', 'left', 'top'
    extra_pixels: lisatavate pikslite arv
    """
    source = Image.open(image_path).convert("RGBA")
    w, h = source.size

    # Arvuta uued mõõtmed
    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)

    # Loo laiendatud lõuend (läbipaistev = genereeritav ala)
    extended = Image.new("RGBA", new_size, (0, 0, 0, 0))
    extended.paste(source, paste_pos)

    # Mask: läbipaistev kõikjal, välja arvatud seal, kus asub originaalpilt
    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)

    # Salvesta ajutiselt
    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"Laiendatud pilt salvestatud: {output_path}")


# Laienda portreed paremale
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"
)

Pane tähele laiendamise prompti sõnastust: „stseeni loomulik jätk, sama valgustus ja taust“. Väljamaalimisel ei kirjelda sa uut objekti; palud mudelil laiendada seda, mida ta juba näeb. Liiga loominguline prompt tekitaks originaali ja lisatud ala vahele nähtava õmbluse.

Iteratiivne redigeerimine

Ei miski takista sul aheldada samale pildile mitut muudatust, kasutades iga väljundit järgmise sammu sisendina. See on kõige usaldusväärsem viis keeruka kompositsiooni loomiseks: tegele esmalt taustaga, seejärel esiplaaniga, kasutades iga läbimise jaoks eraldi maski, selle asemel et loota, et üksainus prompt parandab kõik korraga.

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

# 1. samm: Muuda tausta
step1 = edit_step(
    "scene.png", "mask_background.png",
    "Lush tropical forest background",
    "scene_step1.png"
)

# 2. samm: Lisa element esiplaanile
step2 = edit_step(
    step1, "mask_foreground.png",
    "A colorful macaw parrot perched on a branch",
    "scene_step2.png"
)

print(f"Lõpptulemus: {step2}")

Peamised piirangud

Kõne edu reguleerivad neli tehnilist reeglit. Mis tahes neist rikkumine toob kaasa viivitamatu vea, mitte halvenenud tulemuse.

  • Lähtepildil ja maskil peavad olema samad mõõtmed
  • Mõlemad failid peavad olema PNG-vormingus
  • Faili maksimaalne suurus on 4 MB
  • Mask kasutab muudetavate alade määratlemiseks alfakanalit

Nendele piirangutele lisandub üks empiiriline tähelepanek: tulemused on järjekindlamad, kui maskitud ala moodustab vähem kui 50% pildist. Sellest enamal on mudelil liiga vähe konteksti õigeks sulandumiseks ja sageli saad paremaid tulemusi, kui jagad oma muudatuse kaheks järjestikuseks redigeerimiseks.

Proovi seda praktikas oma laua foto või mõne autorivaba pildiga: kirjuta skript, mis genereerib automaatselt maski pildi ülemisele veerandile, asendab selle ala tähistaevasega ja salvestab tulemuse lokaalselt.