Edytuj istniejące obrazy (inpainting, outpainting)
Na tej stronie
Zaktualizowano 2 listopada 2026 — Modele obrazowe. Model
gpt-image-1, dla którego pierwotnie napisano ten kurs, został wycofany 23 października 2026. Dodatkowo modelegpt-image-1.5,gpt-image-1-miniorazchatgpt-image-latestprzestaną być dostępne 1 grudnia 2026. Przykłady wykorzystują terazgpt-image-2.5-sunburst, który oferuje najwyższą precyzję podczas edycji;gpt-image-2.5-flarejest szybszy przy ogólnym generowaniu. Oba modele obsługują również ustawienia jakościxhighimax. Modele GPT Image zawsze zwracają obrazy w formacie base64: parametrresponse_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.