Crea il tuo filtro con l’IA

Voglio creare due immagini di partenza per dei filtri foto per eventi.

TEMA: [SOSTITUIRE CON IL TEMA]
TESTO ESATTO: [SOSTITUIRE CON IL TESTO]

Voglio 2 immagini separate:

1. una versione verticale in 1080x1620
2. una versione orizzontale in 1620x1080

IMPORTANTE:
Qui non ti chiedo ancora la trasparenza finale.
Ti chiedo soltanto di creare due IMMAGINI DI PARTENZA molto riuscite, estetiche, di alta gamma, che verranno poi scontornate tecnicamente.

Obiettivo visivo:
Creare due cornici foto decorative premium, belle, ricche, armoniose, utilizzabili per foto di persone.

Stile atteso:
- illustrazione premium
- decorativo, elegante, festoso
- stile disegnato a mano / illustrato / acquerello leggero / pennarello raffinato
- dettagli fini
- texture leggere
- contorni puliti
- piccole ombre delicate
- bella composizione
- resa armoniosa e curata

Da evitare assolutamente:
- clipart
- vettoriale piatto
- pittogrammi grossolani
- stile semplicistico
- design infantile
- grandi campiture piatte e pesanti
- manifesto pubblicitario
- resa scadente

Composizione:
- creare una vera cornice decorativa
- elementi grafici concentrati sui bordi, sugli angoli, in alto e in basso
- mantenere una zona centrale molto ampia e vuota per le persone fotografate
- il testo deve essere grande, bello, leggibile, posizionato in basso
- il testo non deve salire troppo in alto
- non mettere personaggi
- non mettere foto
- non mettere decorazioni piene nella zona centrale

Zone da mantenere molto libere:
- verticale: lasciare libera la zona centrale approssimativa x=170..910 e y=330..1320
- orizzontale: lasciare libera la zona centrale approssimativa x=240..1380 e y=220..860

Sfondo di lavoro:
- sfondo uniforme molto chiaro
- bianco sporco o avorio molto chiaro
- senza texture
- senza motivo
- senza scacchiera
- senza sfumatura
- sfondo perfettamente uniforme

Lo sfondo deve restare semplice e uniforme perché verrà poi eliminato tecnicamente.
Ma l’immagine decorativa deve restare molto bella, ricca e premium.

Consegna richiesta:
- un’immagine di partenza verticale 1080x1620
- un’immagine di partenza orizzontale 1620x1080

Ora devi usare LE DUE IMMAGINI CHE HAI APPENA GENERATO poco fa in questa stessa conversazione.

- La prima immagine generata poco fa = sorgente verticale
- La seconda immagine generata poco fa = sorgente orizzontale

IMPORTANTE IN ASSOLUTO:
- Non rigenerare nessuna immagine
- Non ridisegnare nulla
- Non cambiare lo stile
- Non cambiare i colori
- Non cambiare il testo
- Non cambiare la composizione
- Non semplificare nulla
- Non aggiungere nulla
- Non togliere nulla tranne lo sfondo di lavoro uniforme

Devi solo eseguire un TRATTAMENTO TECNICO con Python/Pillow sulle due immagini già generate in questa conversazione per produrre i file finali con vera trasparenza.

File finali da produrre:
1. filter_[tema]_portrait_1080x1620_transparent.png
2. filter_[tema]_landscape_1620x1080_transparent.png

Vincoli obbligatori:
- verticale finale: esattamente 1080x1620
- orizzontale finale: esattamente 1620x1080
- formato PNG
- modalità RGBA
- vera trasparenza alfa

Metodo obbligatorio:
- usare la prima immagine generata poco fa come sorgente verticale
- usare la seconda immagine generata poco fa come sorgente orizzontale
- aprire queste due immagini in RGBA con Python/Pillow
- eliminare solo lo sfondo chiaro uniforme collegato ai bordi e al centro
- non eliminare alla cieca tutti i pixel bianchi
- preservare i fiori bianchi, i dettagli chiari, i contorni, i riflessi e gli elementi decorativi
- mantenere il testo così com’è
- mantenere integralmente il design
- esportare i 2 file finali in PNG trasparente

Usa una logica di flood fill / connected background per eliminare solo lo sfondo collegato.

Codice consigliato:

from PIL import Image
import numpy as np
from collections import deque

def remove_connected_light_background(input_path, output_path, final_size):
    img = Image.open(input_path).convert("RGBA")
    img = img.resize(final_size, Image.LANCZOS)

    arr = np.array(img)
    rgb = arr[..., :3]
    alpha = arr[..., 3]

    h, w = alpha.shape

    light = (
        (rgb[..., 0] > 225) &
        (rgb[..., 1] > 220) &
        (rgb[..., 2] > 210)
    )

    visited = np.zeros((h, w), dtype=bool)
    q = deque()

    seeds = []

    for x in range(w):
        seeds.append((0, x))
        seeds.append((h - 1, x))

    for y in range(h):
        seeds.append((y, 0))
        seeds.append((y, w - 1))

    seeds.append((h // 2, w // 2))

    for y, x in seeds:
        if light[y, x] and not visited[y, x]:
            visited[y, x] = True
            q.append((y, x))

    while q:
        y, x = q.popleft()
        for ny, nx in ((y-1, x), (y+1, x), (y, x-1), (y, x+1)):
            if 0 <= ny < h and 0 <= nx < w:
                if not visited[ny, nx] and light[ny, nx]:
                    visited[ny, nx] = True
                    q.append((ny, nx))

    alpha[visited] = 0
    arr[..., 3] = alpha

    result = Image.fromarray(arr, "RGBA")
    result.save(output_path)

def verify(path, expected_size):
    img = Image.open(path).convert("RGBA")
    assert img.size == expected_size, f"Dimensione errata: {img.size}"

    alpha = np.array(img.getchannel("A"))
    assert alpha.min() == 0, "Nessuna vera trasparenza rilevata"
    assert alpha[expected_size[1] // 2, expected_size[0] // 2] == 0, "Il centro non è trasparente"

    transparent_ratio = (alpha == 0).sum() / alpha.size
    assert transparent_ratio >= 0.55, f"Trasparenza insufficiente: {transparent_ratio:.2%}"

    print(path, "OK", img.size, round(transparent_ratio * 100, 2), "% trasparente")

Verifiche obbligatorie prima di rispondere:
- verticale = esattamente 1080x1620
- orizzontale = esattamente 1620x1080
- i 2 file sono in RGBA
- il pixel centrale ha alfa = 0
- almeno il 55% dell’immagine è totalmente trasparente
- nessuno sfondo chiaro visibile nella zona centrale
- nessuna scacchiera disegnata

Risposta attesa:
- non mostrare le immagini sorgente
- non mostrare anteprime
- non rigenerare le immagini
- rispondi solo con i 2 file PNG finali trasparenti e una breve conferma che le verifiche Python sono passate

Se non puoi eseguire Python/Pillow in questa conversazione, rispondi soltanto:
“Non posso garantire una vera trasparenza PNG in questa conversazione.”