import os import traceback import cv2 import gradio as gr import numpy as np import onnxruntime as ort import spaces from insightface.app import FaceAnalysis from PIL import Image BASE_DIR = os.path.dirname(os.path.abspath(__file__)) MAX_SIDE = 2048 # límite del lado mayor de la imagen destino (evita timeouts) # --------------------------------------------------------------- # Detector / extractor de embeddings (CPU) # --------------------------------------------------------------- app = FaceAnalysis(name="buffalo_l", providers=["CPUExecutionProvider"]) app.prepare(ctx_id=-1, det_size=(640, 640)) # --------------------------------------------------------------- # Carga de modelos ONNX (CPU) # --------------------------------------------------------------- def cargar_modelo(nombre_archivo, etiqueta): ruta = os.path.join(BASE_DIR, nombre_archivo) try: s = ort.InferenceSession(ruta, providers=["CPUExecutionProvider"]) print(f"¡{etiqueta} cargado correctamente!") for inp in s.get_inputs(): print(" Input:", inp.name, inp.shape, inp.type) for out in s.get_outputs(): print(" Output:", out.name, out.shape, out.type) return s except Exception as e: print(f"Error al cargar {etiqueta} ({nombre_archivo}):", e) return None sess = cargar_modelo("hyperswap_1a_256.onnx", "HyperSwap (swap)") sess_occ = cargar_modelo("face_occluder.onnx", "Oclusor facial") sess_enh = cargar_modelo("GPEN-BFR-512.onnx", "GPEN-BFR-512 (mejorador)") # Plantilla de alineación (arcface 128 normalizada) TEMPLATE_NORM = np.array( [ [0.36167656, 0.40387734], [0.63696719, 0.40235469], [0.50019687, 0.56044219], [0.38710391, 0.72160547], [0.61507734, 0.72034453], ], dtype=np.float32, ) # --------------------------------------------------------------- # Utilidades # --------------------------------------------------------------- def cara_principal(caras): """Devuelve la cara con mayor área (la más prominente).""" return max( caras, key=lambda c: (c.bbox[2] - c.bbox[0]) * (c.bbox[3] - c.bbox[1]), ) def pil_a_bgr(imagen_pil, limitar=False): img = cv2.cvtColor(np.array(imagen_pil.convert("RGB")), cv2.COLOR_RGB2BGR) if limitar: h, w = img.shape[:2] mayor = max(h, w) if mayor > MAX_SIDE: escala = MAX_SIDE / mayor img = cv2.resize( img, (int(w * escala), int(h * escala)), interpolation=cv2.INTER_AREA ) return img def matriz_alineacion(kps, size): M, _ = cv2.estimateAffinePartial2D( kps.astype(np.float32), TEMPLATE_NORM * size, method=cv2.LMEDS ) return M def mascara_caja(size, blur=0.3): """Máscara rectangular con bordes suaves (para pegar el rostro mejorado).""" blur_amount = int(size * 0.5 * blur) blur_area = max(blur_amount // 2, 1) caja = np.ones((size, size), dtype=np.float32) caja[:blur_area, :] = 0 caja[-blur_area:, :] = 0 caja[:, :blur_area] = 0 caja[:, -blur_area:] = 0 if blur_amount > 0: caja = cv2.GaussianBlur(caja, (0, 0), blur_amount * 0.25) return caja # --------------------------------------------------------------- # Máscara de oclusión (gafas, manos, objetos delante de la cara) # --------------------------------------------------------------- def mascara_oclusion(crop_bgr): """Devuelve una máscara 256x256 (1 = cara visible, 0 = ocluido) o None.""" if sess_occ is None: return None try: inp = sess_occ.get_inputs()[0] x = cv2.resize(crop_bgr, (256, 256)).astype(np.float32) / 255.0 x = x[np.newaxis, ...] # NHWC forma = inp.shape if isinstance(forma, (list, tuple)) and len(forma) == 4 and forma[1] == 3: x = np.transpose(x, (0, 3, 1, 2)) # el modelo pide NCHW x = np.ascontiguousarray(x, dtype=np.float32) salida = sess_occ.run(None, {inp.name: x})[0] m = np.squeeze(salida).astype(np.float32) while m.ndim > 2: m = m[0] m = cv2.resize(m, (256, 256)) m = np.clip(m, 0, 1) m = cv2.GaussianBlur(m, (0, 0), 5) m = (np.clip(m, 0.5, 1.0) - 0.5) * 2.0 return m.astype(np.float32) except Exception: print("Aviso: falló la máscara de oclusión:", traceback.format_exc()) return None # --------------------------------------------------------------- # Mejorador de rostro GPEN-BFR-512 # --------------------------------------------------------------- def mejorar_rostro(img_bgr, kps, mezcla): """Aplica GPEN sobre el rostro ya intercambiado y lo mezcla con la imagen.""" h, w = img_bgr.shape[:2] M = matriz_alineacion(kps, 512) crop = cv2.warpAffine( img_bgr, M, (512, 512), flags=cv2.INTER_LINEAR, borderMode=cv2.BORDER_REPLICATE ) x = crop[:, :, ::-1].astype(np.float32) / 255.0 x = (x - 0.5) / 0.5 x = np.ascontiguousarray(np.transpose(x, (2, 0, 1))[np.newaxis, ...], dtype=np.float32) inp = sess_enh.get_inputs()[0] y = sess_enh.run(None, {inp.name: x})[0][0] y = (np.clip(y, -1, 1) + 1) / 2 y = np.transpose(y, (1, 2, 0)) * 255.0 y = np.clip(np.round(y), 0, 255).astype(np.uint8)[:, :, ::-1] y = np.ascontiguousarray(y) IM = cv2.invertAffineTransform(M) pegado = cv2.warpAffine(y, IM, (w, h), flags=cv2.INTER_CUBIC, borderMode=cv2.BORDER_REPLICATE) mascara = cv2.warpAffine(mascara_caja(512), IM, (w, h), flags=cv2.INTER_LINEAR, borderValue=0.0) mascara = np.clip(mascara, 0, 1)[:, :, np.newaxis] * (float(mezcla) / 100.0) salida = img_bgr.astype(np.float32) * (1 - mascara) + pegado.astype(np.float32) * mascara return np.clip(salida, 0, 255).astype(np.uint8) # --------------------------------------------------------------- # Proceso principal # --------------------------------------------------------------- @spaces.GPU(duration=120) def predecir( imagen_destino_pil, imagen_fuente_pil, usar_oclusion=True, usar_mejora=True, mezcla_mejora=80, ): if sess is None: return None, "Error: El modelo HyperSwap (ONNX) no se cargó." if imagen_destino_pil is None or imagen_fuente_pil is None: return None, "Por favor, sube ambas imágenes." try: pasos = [] img_destino = pil_a_bgr(imagen_destino_pil, limitar=True) img_fuente = pil_a_bgr(imagen_fuente_pil) caras_destino = app.get(img_destino) caras_fuente = app.get(img_fuente) if len(caras_destino) == 0: return None, "No se detectó rostro en la imagen de DESTINO." if len(caras_fuente) == 0: return None, "No se detectó rostro en la imagen de ORIGEN." cara_destino = cara_principal(caras_destino) cara_fuente = cara_principal(caras_fuente) # Embedding normalizado (L2) emb = cara_fuente.embedding.reshape(1, -1).astype(np.float32) source_embedding = emb / np.linalg.norm(emb) # Alineación del rostro destino a 256x256 M = matriz_alineacion(cara_destino.kps, 256) aligned_face = cv2.warpAffine( img_destino, M, (256, 256), flags=cv2.INTER_LINEAR, borderMode=cv2.BORDER_REPLICATE, ) # Preprocesado: BGR->RGB, normalizar a [-1, 1], NCHW target_tensor = aligned_face.astype(np.float32)[:, :, ::-1] target_tensor = (target_tensor / 255.0 - 0.5) / 0.5 target_tensor = np.transpose(target_tensor, (2, 0, 1))[np.newaxis, ...] target_tensor = np.ascontiguousarray(target_tensor, dtype=np.float32) input_names = [inp.name for inp in sess.get_inputs()] if len(input_names) >= 2: inputs = {input_names[0]: source_embedding, input_names[1]: target_tensor} else: inputs = {"source": source_embedding, "target": target_tensor} outputs = sess.run(None, inputs) swapped_face = outputs[0][0] swapped_mask = outputs[1][0][0] pasos.append("swap HyperSwap") # Posprocesado: [-1, 1] -> [0, 255], CHW->HWC, RGB->BGR swapped_face = (swapped_face * 0.5 + 0.5) * 255.0 swapped_face = np.clip(swapped_face, 0, 255).astype(np.uint8) swapped_face = np.transpose(swapped_face, (1, 2, 0))[:, :, ::-1] swapped_face = np.ascontiguousarray(swapped_face) mascara_crop = np.clip(swapped_mask, 0, 1).astype(np.float32) # Oclusiones (gafas, manos, etc.): se combinan con la máscara del swap if usar_oclusion and sess_occ is not None: occ = mascara_oclusion(aligned_face) if occ is not None: mascara_crop = np.minimum(mascara_crop, occ) pasos.append("máscara de oclusión") # Suavizar el borde de la máscara para evitar costuras mascara_crop = cv2.GaussianBlur(mascara_crop, (0, 0), 3) mascara_crop = np.clip(mascara_crop, 0, 1) # Volver a la imagen original h, w = img_destino.shape[:2] IM = cv2.invertAffineTransform(M) img_swap = cv2.warpAffine( swapped_face, IM, (w, h), flags=cv2.INTER_CUBIC, borderMode=cv2.BORDER_REPLICATE ) mask = cv2.warpAffine( mascara_crop, IM, (w, h), flags=cv2.INTER_LINEAR, borderValue=0.0 ) mask = np.clip(mask, 0, 1)[:, :, np.newaxis] resultado = ( img_destino.astype(np.float32) * (1 - mask) + img_swap.astype(np.float32) * mask ) resultado = np.clip(resultado, 0, 255).astype(np.uint8) # Mejora de rostro con GPEN-BFR-512 if usar_mejora and sess_enh is not None and mezcla_mejora > 0: try: resultado = mejorar_rostro(resultado, cara_destino.kps, mezcla_mejora) pasos.append(f"mejora GPEN ({int(mezcla_mejora)}%)") except Exception: print("Aviso: falló el mejorador GPEN:", traceback.format_exc()) pasos.append("mejora GPEN omitida por error") resultado_pil = Image.fromarray(cv2.cvtColor(resultado, cv2.COLOR_BGR2RGB)) return resultado_pil, "¡Face swap completado con éxito! 🎭\nPasos: " + ", ".join(pasos) except Exception: return None, "Error: " + traceback.format_exc() with gr.Blocks(title="Swapper Face") as demo: gr.Markdown( "# 🎭 Swapper Face Real - Sube la imagen de destino (fondo) " "y la cara que quieres ponerle." ) with gr.Row(): with gr.Column(): img_destino = gr.Image(type="pil", label="1. Imagen de Destino (Fondo)") img_fuente = gr.Image(type="pil", label="2. Imagen de Origen (Cara a extraer)") usar_oclusion = gr.Checkbox( value=True, label="Respetar oclusiones (gafas, manos, objetos)" ) usar_mejora = gr.Checkbox(value=True, label="Mejorar rostro (GPEN-BFR-512)") mezcla_mejora = gr.Slider( 0, 100, value=80, step=5, label="Intensidad de la mejora (%)" ) boton_ejecutar = gr.Button("🔄 Ejecutar Swapper", variant="primary") with gr.Column(): salida_imagen = gr.Image(type="pil", label="Resultado Final") salida_texto = gr.Textbox(label="Estado del proceso", lines=5) boton_ejecutar.click( fn=predecir, inputs=[img_destino, img_fuente, usar_oclusion, usar_mejora, mezcla_mejora], outputs=[salida_imagen, salida_texto], ) if __name__ == "__main__": demo.launch()