Salt la conținutul principal
Română— Alege o limbă
Meniu

Editarea imaginilor existente (inpainting, outpainting)

Lecția 3 din 12 Actualizată 2 noiembrie 2026 Dezvoltator
Pe această pagină
  1. Editarea imaginilor existente
  2. Cum funcționează masca
  3. Inpainting: Înlocuirea unui element
  4. Outpainting: Extinderea imaginii
  5. Editarea iterativă
  6. Constrângeri cheie

Actualizat pe 2 noiembrie 2026 — Modele de imagini. gpt-image-1, modelul pentru care a fost scris inițial acest curs, a fost retras din uz la 23 octombrie 2026. În plus, gpt-image-1.5, gpt-image-1-mini și chatgpt-image-latest vor fi retrase la 1 decembrie 2026. Exemplele folosesc acum gpt-image-2.5-sunburst, care oferă cea mai mare precizie pentru editare; gpt-image-2.5-flare este mai rapid pentru generarea generală. Ambele modele suportă, de asemenea, setările de calitate xhigh și max. Modelele GPT Image returnează întotdeauna imaginile în format base64: parametrul response_format utilizat de modelele DALL·E mai vechi nu mai este acceptat și a fost eliminat din cod. Sursă: Generarea imaginilor (OpenAI).

Editarea imaginilor existente

Metoda client.images.edit() modifică o imagine existentă folosind o mască pentru a defini zona care urmează a fi regenerată. Acest lucru duce la două cazuri de utilizare distincte, care merită denumite cu precizie deoarece necesită măști diferite. Inpainting-ul umple sau înlocuiește o zonă interioară—puteți schimba cerul într-un peisaj, ecranul unui computer sau culoarea unui perete. Outpainting-ul, dimpotrivă, extinde imaginea dincolo de marginile sale originale, transformând de exemplu un portret pătrat într-un banner panoramic.

Cum funcționează masca

Masca este o imagine PNG cu aceleași dimensiuni ca imaginea sursă. Zonele transparente (alfa = 0) indică locul unde modelul trebuie să genereze conținut nou; zonele opace rămân neatinsе. Această convenție este contraintuitivă la început: în mod natural, doriți să „pictați“ ceea ce doriți să schimbați, dar de fapt trebuie să decupați o gaură în mască. Apelul API în sine rămâne simplu, necesitând doar cele două fișiere și o descriere a ceea ce trebuie să apară.

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

Nu aveți nevoie de un editor grafic pentru a crea această mască. Pillow poate genera una în doar câteva linii: începeți cu un strat complet opac care corespunde dimensiunilor sursei, apoi desenați forma pe care doriți să o faceți transparentă. Scriptul de mai jos creează o fereastră dreptunghiulară în centrul imaginii.

from PIL import Image, ImageDraw

# Încărcați imaginea sursă pentru a obține dimensiunile acesteia
source = Image.open("desk_photo.png")
width, height = source.size

# Creați o mască complet opacă (negru)
mask = Image.new("RGBA", (width, height), (0, 0, 0, 255))
draw = ImageDraw.Draw(mask)

# Desenați o zonă transparentă (zona de editat)
# Dreptunghi în centrul imaginii
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"Masca creată: {width}x{height}, zonă editabilă în centru")

Inpainting: Înlocuirea unui element

Odată ce repetați această operațiune, are sens să încapsulați crearea măștii și apelul API într-o singură funcție, parametrizată de regiunea de modificat. Promptul trebuie apoi să descrie doar conținutul așteptat în interiorul zonei mascate, niciodată restul imaginii. Exemplul de mai jos aplică această funcție unei fotografii de peisaj, modificând doar primii 400 de pixeli din partea superioară—cerul—pentru a-i conferi o atmosferă furtunoasă.

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

client = OpenAI()

def inpaint_region(image_path, region, prompt, output_path):
    """
    Înlocuiește o regiune dreptunghiulară într-o imagine.
    region: tuplu (x1, y1, x2, y2) în pixeli
    """
    # Crearea măștii
    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")

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

    # Salvarea rezultatului
    with open(output_path, "wb") as f:
        f.write(base64.b64decode(response.data[0].b64_json))
    print(f"Imagine editată salvată: {output_path}")


# Exemplu: Înlocuirea cerului într-o fotografie de peisaj
inpaint_region(
    image_path="landscape.png",
    region=(0, 0, 1024, 400),  # Partea superioară = cerul
    prompt="Dramatic sky with purple storm clouds at sunset",
    output_path="landscape_sky_edited.png"
)

Outpainting: Extinderea imaginii

Mărirea unei imagini necesită un pas suplimentar, deoarece API-ul nu poate genera conținut „lângă“ un fișier direct. Trebuie mai întâi să creați o pânză mai mare, să lipiți originalul pe aceasta și să furnizați o mască ce protejează exact zona ocupată de originalul respectiv. Întreaga logică se bazează pe calcularea noilor dimensiuni și a poziției de lipire în funcție de direcția solicitată.

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):
    """
    Extinde o imagine într-o direcție dată.
    direction: 'right', 'bottom', 'left', 'top'
    extra_pixels: numărul de pixeli de adăugat
    """
    source = Image.open(image_path).convert("RGBA")
    w, h = source.size

    # Calcularea noilor dimensiuni
    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)

    # Crearea pânzei extinse (transparent = zona de generat)
    extended = Image.new("RGBA", new_size, (0, 0, 0, 0))
    extended.paste(source, paste_pos)

    # Masca: transparentă peste tot, exceptând zona unde este plasată imaginea originală
    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)

    # Salvare temporară
    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"Imagine extinsă salvată: {output_path}")


# Extinderea unui portret spre dreapta
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"
)

Observați formularea promptului de extindere: „continuarea naturală a scenei, aceeași iluminare și fundal“. În outpainting, nu descrieți un subiect nou; cereți modelului să extindă ceea ce vede deja. Un prompt prea creativ ar produce o cusătură vizibilă între original și zona adăugată.

Editarea iterativă

Nimic nu vă împiedică să înlănțuiți mai multe editări pe aceeași imagine, folosind fiecare ieșire ca intrare pentru pasul următor. Aceasta este cea mai fiabilă metodă de a construi o compoziție complexă: gestionați mai întâi fundalul, apoi prim-planul, cu o mască dedicată pentru fiecare trecere, în loc să sperați că un singur prompt va rezolva totul dintr-o dată.

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

# Pasul 1: Modificarea fundalului
step1 = edit_step(
    "scene.png", "mask_background.png",
    "Lush tropical forest background",
    "scene_step1.png"
)

# Pasul 2: Adăugarea unui element în prim-plan
step2 = edit_step(
    step1, "mask_foreground.png",
    "A colorful macaw parrot perched on a branch",
    "scene_step2.png"
)

print(f"Rezultat final: {step2}")

Constrângeri cheie

Patru reguli tehnice guvernează succesul apelului. Încălcarea oricăreia dintre ele duce la o eroare imediată, nu la un rezultat degradat.

  • Imaginea sursă și masca trebuie să aibă aceleași dimensiuni
  • Ambele fișiere trebuie să fie în format PNG
  • Dimensiunea maximă per fișier este de 4 MB
  • Masca folosește canalul alfa pentru a defini zonele editabile

O observație empirică se adaugă acestor constrângeri: rezultatele sunt mai consistente când zona mascată reprezintă mai puțin de 50% din imagine. Dincolo de acest prag, modelul are prea puțin context pentru a realiza o îmbinare corectă, iar adesea veți obține rezultate mai bune dacă divizați modificarea în două editări succesive.

Puneți acest lucru în practică cu o fotografie a biroului dumneavoastră sau cu orice imagine fără drepturi de autor: scrieți un script care generează automat o mască peste sfertul superior al imaginii, înlocuiește acea zonă cu un cer înstelat și salvează rezultatul local.