Crea tu filtro con IA

Quiero crear dos visuales de origen para filtros de fotos de evento.

TEMA: [REEMPLAZAR POR EL TEMA]
TEXTO EXACTO: [REEMPLAZAR POR EL TEXTO]

Quiero 2 imágenes separadas:

1. una versión vertical en 1080x1620
2. una versión horizontal en 1620x1080

IMPORTANTE:
En esta etapa, aún no pido la transparencia final.
Solo te pido que crees dos VISUALES DE ORIGEN muy logrados, estéticos y de alta gama, que luego se recortarán técnicamente.

Objetivo visual:
Crear dos marcos decorativos de fotos premium, bonitos, ricos, armoniosos, utilizables para fotos de personas.

Estilo esperado:
- ilustración premium
- decorativo, elegante, festivo
- estilo dibujado a mano / ilustrado / acuarela ligera / rotulador refinado
- detalles finos
- texturas ligeras
- contornos limpios
- pequeñas sombras sutiles
- composición bonita
- resultado armonioso y pulido

A evitar absolutamente:
- clipart
- vector plano
- pictogramas toscos
- estilo simplista
- diseño infantil
- bloques de color sólido pesados
- cartel publicitario
- resultado barato

Composición:
- crear un verdadero marco decorativo
- elementos visuales concentrados en los bordes, las esquinas, la parte superior e inferior
- mantener una amplia zona central vacía para las personas fotografiadas
- el texto debe ser grande, bonito, legible, colocado en la parte inferior
- el texto no debe subir demasiado
- no incluir ningún personaje
- no incluir ninguna foto
- no poner una decoración completa en la zona central

Zonas que deben quedar muy despejadas:
- vertical: dejar libre la zona central aproximada x=170..910 e y=330..1320
- horizontal: dejar libre la zona central aproximada x=240..1380 e y=220..860

Fondo de trabajo:
- fondo uniforme muy claro
- blanco roto o marfil muy claro
- sin textura
- sin patrón
- sin tablero de ajedrez
- sin degradado
- fondo perfectamente uniforme

El fondo debe permanecer simple y uniforme porque se eliminará técnicamente después.
Pero el visual decorativo debe seguir siendo muy bonito, rico y premium.

Entrega solicitada:
- una imagen de origen vertical 1080x1620
- una imagen de origen horizontal 1620x1080

Ahora debes usar LAS DOS IMÁGENES QUE ACABAS DE GENERAR antes en esta misma conversación.

- La primera imagen generada antes = origen vertical
- La segunda imagen generada antes = origen horizontal

ABSOLUTAMENTE IMPORTANTE:
- No regeneres ninguna imagen
- No vuelvas a dibujar nada
- No cambies el estilo
- No cambies los colores
- No cambies el texto
- No cambies la composición
- No simplifiques nada
- No añadas nada
- No elimines nada salvo el fondo de trabajo uniforme

Solo debes realizar un PROCESAMIENTO TÉCNICO con Python/Pillow sobre las dos imágenes ya generadas en esta conversación para producir los archivos finales con transparencia real.

Archivos finales a producir:
1. filter_[theme]_portrait_1080x1620_transparent.png
2. filter_[theme]_landscape_1620x1080_transparent.png

Restricciones obligatorias:
- vertical final: exactamente 1080x1620
- horizontal final: exactamente 1620x1080
- formato PNG
- modo RGBA
- transparencia alfa real

Método obligatorio:
- usar la primera imagen generada antes como origen vertical
- usar la segunda imagen generada antes como origen horizontal
- abrir estas dos imágenes en RGBA con Python/Pillow
- eliminar solo el fondo claro uniforme conectado a los bordes y al centro
- no eliminar a ciegas todos los píxeles blancos
- preservar flores blancas, detalles claros, contornos, reflejos y elementos decorativos
- mantener el texto tal cual
- mantener el diseño por completo
- exportar los 2 archivos finales como PNG transparente

Usa una lógica de relleno por difusión / fondo conectado para eliminar solo el fondo conectado.

Código recomendado:

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"Mauvaise taille : {img.size}"

    alpha = np.array(img.getchannel("A"))
    assert alpha.min() == 0, "Aucune vraie transparence détectée"
    assert alpha[expected_size[1] // 2, expected_size[0] // 2] == 0, "Le centre n’est pas transparent"

    transparent_ratio = (alpha == 0).sum() / alpha.size
    assert transparent_ratio >= 0.55, f"Pas assez de transparence : {transparent_ratio:.2%}"

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

Verificaciones obligatorias antes de responder:
- vertical = exactamente 1080x1620
- horizontal = exactamente 1620x1080
- los 2 archivos son RGBA
- el píxel central tiene alfa = 0
- al menos el 55% de la imagen es totalmente transparente
- sin fondo claro visible en la zona central
- sin tablero de ajedrez dibujado

Respuesta esperada:
- no muestres las imágenes de origen
- no muestres una vista previa
- no regeneres las imágenes
- responde solo con los 2 archivos PNG transparentes finales y una breve confirmación de que las verificaciones de Python pasaron

Si no puedes ejecutar Python/Pillow en esta conversación, responde solo:
“No puedo garantizar una transparencia PNG real en esta conversación.”