Przejdź do głównej treści
Polski— Wybierz język
Menu

Edytuj istniejące obrazy (inpainting, outpainting)

Lekcja 3 z 12 Zaktualizowano 2 listopada 2026 Programista
Na tej stronie
  1. Edycja istniejących obrazów
  2. Jak działa maska
  3. Inpainting: Zastąp element
  4. Outpainting: Rozszerz obraz
  5. Edycja iteracyjna
  6. Kluczowe ograniczenia

Zaktualizowano 2 listopada 2026 — Modele obrazowe. Model gpt-image-1, dla którego pierwotnie napisano ten kurs, został wycofany 23 października 2026. Dodatkowo modele gpt-image-1.5, gpt-image-1-mini oraz chatgpt-image-latest przestaną być dostępne 1 grudnia 2026. Przykłady wykorzystują teraz gpt-image-2.5-sunburst, który oferuje najwyższą precyzję podczas edycji; gpt-image-2.5-flare jest szybszy przy ogólnym generowaniu. Oba modele obsługują również ustawienia jakości xhigh i max. Modele GPT Image zawsze zwracają obrazy w formacie base64: parametr response_format, używany przez starsze modele DALL·E, nie jest już akceptowany i został usunięty z kodu. Źródło: Image generation (OpenAI).

Edycja istniejących obrazów

Metoda client.images.edit() modyfikuje istniejący obraz, używając maski do zdefiniowania obszaru podlegającego regeneracji. Prowadzi to do dwóch odrębnych przypadków użycia, które warto precyzyjnie nazwać, ponieważ wymagają one różnych masek. Inpainting wypełnia lub zastępuje wewnętrzny obszar — możesz zmienić niebo na pejzażu, ekran komputera lub kolor ściany. Outpainting z kolei rozszerza obraz poza jego oryginalne granice, na przykład zamieniając kwadratowy portret w panoramiczny baner.

Jak działa maska

Maska to obraz PNG o tych samych wymiarach co obraz źródłowy. Obszary przezroczyste (alfa = 0) wskazują miejsce, w którym model powinien wygenerować nową zawartość; obszary nieprzezroczyste pozostają nienaruszone. Ta konwencja jest na pierwszy rzut oka kontrintuicyjna: naturalnie chcesz „namalować“ to, co chcesz zmienić, ale w rzeczywistości musisz wyciąć otwór w masce. Samo wywołanie API pozostaje proste i wymaga jedynie dwóch plików oraz opisu tego, co ma się pojawić.

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

Nie potrzebujesz edytora graficznego, aby stworzyć taką maskę. Biblioteka Pillow może wygenerować ją w zaledwie kilku liniach: zacznij od w pełni nieprzezroczystej warstwy odpowiadającej wymiarom źródła, a następnie narysuj kształt, który chcesz uczynić przezroczystym. Poniższy skrypt tworzy prostokątne okno na środku obrazu.

from PIL import Image, ImageDraw

# Wczytaj obraz źródłowy, aby uzyskać jego wymiary
source = Image.open("desk_photo.png")
width, height = source.size

# Utwórz w pełni nieprzezroczystą maskę (czarną)
mask = Image.new("RGBA", (width, height), (0, 0, 0, 255))
draw = ImageDraw.Draw(mask)

# Narysuj przezroczysty obszar (obszar do edycji)
# Prostokąt na środku obrazu
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 created: {width}x{height}, editable area in center")

Inpainting: Zastąp element

Gdy powtórzysz tę operację, warto zamknąć tworzenie maski i wywołanie API w jednej funkcji, parametryzowanej przez region do modyfikacji. Prompt powinien wtedy opisywać wyłącznie zawartość oczekiwaną wewnątrz zamaskowanego obszaru, nigdy reszty obrazu. Poniższy przykład stosuje tę funkcję do fotografii pejzażu, modyfikując tylko górne 400 pikseli — niebo — aby nadać mu burzliwą atmosferę.

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

client = OpenAI()

def inpaint_region(image_path, region, prompt, output_path):
    """
    Zastąp prostokątny region w obrazie.
    region: krotka (x1, y1, x2, y2) w pikselach
    """
    # Utwórz 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")

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

    # Zapisz wynik
    with open(output_path, "wb") as f:
        f.write(base64.b64decode(response.data[0].b64_json))
    print(f"Edited image saved: {output_path}")


# Przykład: Zastąp niebo na zdjęciu pejzażu
inpaint_region(
    image_path="landscape.png",
    region=(0, 0, 1024, 400),  # Górna część = niebo
    prompt="Dramatic sky with purple storm clouds at sunset",
    output_path="landscape_sky_edited.png"
)

Outpainting: Rozszerz obraz

Powiększenie obrazu wymaga dodatkowego kroku, ponieważ API nie może generować treści „obok“ pliku bezpośrednio. Musisz najpierw stworzyć większe płótno, wkleić na nie oryginał i dostarczyć maskę, która chroni dokładnie obszar zajmowany przez ten oryginał. Cała logika opiera się na obliczeniu nowych wymiarów i pozycji wklejenia w zależności od żądanego kierunku.

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):
    """
    Rozszerz obraz w danym kierunku.
    direction: 'right', 'bottom', 'left', 'top'
    extra_pixels: liczba pikseli do dodania
    """
    source = Image.open(image_path).convert("RGBA")
    w, h = source.size

    # Oblicz nowe wymiary
    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)

    # Utwórz rozszerzone płótno (przezroczyste = obszar do wygenerowania)
    extended = Image.new("RGBA", new_size, (0, 0, 0, 0))
    extended.paste(source, paste_pos)

    # Maska: przezroczysta wszędzie oprócz miejsca, gdzie umieszczono oryginalny obraz
    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)

    # Zapisz tymczasowo
    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"Extended image saved: {output_path}")


# Rozszerz portret w prawo
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"
)

Zwróć uwagę na sformułowanie promptu rozszerzającego: „naturalna kontynuacja sceny, takie samo oświetlenie i tło“. W outpaintingu nie opisujesz nowego obiektu; prosisz model o rozszerzenie tego, co już widzi. Zbyt kreatywny prompt spowodowałby widoczny szew między oryginałem a dodanym obszarem.

Edycja iteracyjna

Nic nie stoi na przeszkodzie, aby łączyć wiele edycji na tym samym obrazie, używając każdego wyniku jako wejścia dla kolejnego kroku. To najbardziej niezawodny sposób na budowanie złożonej kompozycji: zajmij się najpierw tłem, potem pierwszym planem, z dedykowaną maską dla każdego przebiegu, zamiast mieć nadzieję, że jeden prompt naprawi wszystko naraz.

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

# Krok 1: Modyfikuj tło
step1 = edit_step(
    "scene.png", "mask_background.png",
    "Lush tropical forest background",
    "scene_step1.png"
)

# Krok 2: Dodaj element na pierwszy plan
step2 = edit_step(
    step1, "mask_foreground.png",
    "A colorful macaw parrot perched on a branch",
    "scene_step2.png"
)

print(f"Final result: {step2}")

Kluczowe ograniczenia

Cztery zasady techniczne decydują o powodzeniu wywołania. Naruszenie którejkolwiek z nich skutkuje natychmiastowym błędem, a nie pogorszonym wynikiem.

  • Obraz źródłowy i maska muszą mieć te same wymiary
  • Oba pliki muszą być w formacie PNG
  • Maksymalny rozmiar pliku to 4 MB
  • Maska używa kanału alfa do definiowania obszarów edytowalnych

Do tych ograniczeń dochodzi jedna obserwacja empiryczna: wyniki są bardziej spójne, gdy zamaskowany obszar stanowi mniej niż 50% obrazu. Powyżej tej wartości model ma zbyt mało kontekstu, aby poprawnie scalać elementy, i często uzyskasz lepsze rezultaty, dzieląc modyfikację na dwie kolejne edycje.

Wprowadź to w praktyce, używając zdjęcia swojego biurka lub dowolnego obrazu z licencją royalty-free: napisz skrypt, który automatycznie generuje maskę na górnej ćwiartce obrazu, zastępuje ten obszar rozgwieżdżonym niebem i zapisuje wynik lokalnie.