Update app.py

app.py

@@ -1,189 +1,37 @@
 import spaces
 import gradio as gr
-from PIL import Image, ImageChops, ImageFilter, ImageOps
+from PIL import Image
 import io
 import os
-import numpy as np
-import cv2
 
-# Initialize rembg session
-from rembg import remove, new_session
-_SESSION = new_session("isnet-general-use")
-
-def remove_background(img: Image.Image) -> Image.Image:
-    rgba = img.convert("RGBA")
-    mask = remove(rgba, session=_SESSION, only_mask=True)
-    alpha = mask.convert("L") if isinstance(mask, Image.Image) else Image.open(io.BytesIO(mask)).convert("L")
-    if alpha.size != rgba.size:
-        alpha = alpha.resize(rgba.size, Image.Resampling.LANCZOS)
-    r, g, b, _ = rgba.split()
-    return Image.merge("RGBA", (r, g, b, alpha))
-
-def blur_faces_smooth(image: Image.Image) -> tuple[Image.Image, list]:
-    """
-    Detects faces using multiple Haar Cascades (frontal, alt, profile) to ensure
-    all faces in group/couple photos are found, and applies a heavy Gaussian blur.
-    """
-    rgba = image.convert("RGBA")
-    width, height = rgba.size
-    
-    # Convert PIL Image to OpenCV grayscale for detection
-    open_cv_image = np.array(rgba.convert("RGB"))
-    open_cv_image = open_cv_image[:, :, ::-1].copy() # Convert RGB to BGR
-    gray = cv2.cvtColor(open_cv_image, cv2.COLOR_BGR2GRAY)
-    
-    # Load frontal and profile cascades for maximum coverage
-    face_cascade_default = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
-    face_cascade_alt = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_alt2.xml')
-    profile_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_profileface.xml')
-    
-    faces_default = face_cascade_default.detectMultiScale(gray, scaleFactor=1.05, minNeighbors=3, minSize=(20, 20))
-    faces_alt = face_cascade_alt.detectMultiScale(gray, scaleFactor=1.05, minNeighbors=3, minSize=(20, 20))
-    faces_profile = profile_cascade.detectMultiScale(gray, scaleFactor=1.05, minNeighbors=3, minSize=(20, 20))
-    
-    # Combine detected faces
-    faces = []
-    if len(faces_default) > 0: faces.extend(faces_default)
-    if len(faces_alt) > 0: faces.extend(faces_alt)
-    if len(faces_profile) > 0: faces.extend(faces_profile)
-    
-    if len(faces) == 0:
-        # Fallback: soft feathered blur on upper center if no faces detected
-        mask = Image.new("L", (width, height), 0)
-        mask_np = np.array(mask)
-        # generic head ellipse at top center
-        cx, cy = width // 2, int(height * 0.32)
-        rx, ry = int(width * 0.25), int(height * 0.18)
-        cv2.ellipse(mask_np, (cx, cy), (rx, ry), 0, 0, 360, 255, -1)
-        mask = Image.fromarray(mask_np).filter(ImageFilter.GaussianBlur(radius=20))
-        
-        blurred_img = rgba.filter(ImageFilter.GaussianBlur(radius=25))
-        return Image.composite(blurred_img, rgba, mask), []
-
-    # Create a smooth, feathered mask (0 = original, 255 = blurred)
-    mask = Image.new("L", (width, height), 0)
-    mask_np = np.array(mask)
-    
-    for (x, y, w, h) in faces:
-        cx = x + w // 2
-        
-        # Shift the blur down to cover eyes/mouth and chin, keeping eyebrows untouched.
-        # rx covers almost the entire face width (w * 0.48, or 96% of w)
-        # ry and cy_shifted cover from y + 0.33 * h to y + 0.97 * h, containing all eyes/nose/mouth/cheeks
-        rx = int(w * 0.48)
-        ry = int(h * 0.32)
-        cy_shifted = y + int(h * 0.65)
-        
-        cv2.ellipse(mask_np, (cx, cy_shifted), (rx, ry), 0, 0, 360, 255, -1)
-        
-    mask = Image.fromarray(mask_np)
-    # Heavy blur on mask to feather edges completely smoothly
-    mask = mask.filter(ImageFilter.GaussianBlur(radius=10))
-    
-    # Generate the heavily blurred version of the face areas
-    blurred_img = rgba.filter(ImageFilter.GaussianBlur(radius=35))
-    
-    # Composite the blurred face areas onto the original image
-    return Image.composite(blurred_img, rgba, mask), list(faces)
-
-def extract_fine_details_cv2(img: Image.Image, detail_profile="balanced") -> Image.Image:
-    """
-    Uses Bilateral Filter and Canny Edge Detector to extract thick, clean lines.
-    """
-    # Convert PIL Image to OpenCV (BGR)
-    open_cv_image = np.array(img.convert("RGB"))
-    open_cv_image = open_cv_image[:, :, ::-1].copy() # Convert RGB to BGR
-    
-    # Convert to grayscale
-    gray = cv2.cvtColor(open_cv_image, cv2.COLOR_BGR2GRAY)
-    
-    # Heavy Bilateral filter removes small details and fabric texture while keeping main edges sharp
-    smoothed = cv2.bilateralFilter(gray, d=9, sigmaColor=75, sigmaSpace=75)
-    
-    # Set Canny thresholds based on profile (lowered thresholds to prevent losing main lines)
-    if detail_profile == "soft":
-        t1, t2 = 40, 130
-    elif detail_profile == "balanced":
-        t1, t2 = 18, 75
-    else:  # raw / detailed
-        t1, t2 = 10, 50
-        
-    # Run Canny edge detector
-    edges = cv2.Canny(smoothed, t1, t2)
-    
-    # Dilate with a 3x3 kernel to make lines thicker and more suitable for embroidery representation
-    kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (3, 3))
-    edges_dilated = cv2.dilate(edges, kernel, iterations=1)
-    
-    # Convert back to PIL Image (L mode)
-    return Image.fromarray(edges_dilated).convert("L")
-
-def generate_alpha_outline_cv2(alpha: Image.Image) -> Image.Image:
-    """
-    Generates a clean, thicker boundary outline using morphological gradient.
-    """
-    alpha_np = np.array(alpha)
-    
-    # Morphological gradient (dilate - erode) with a 3x3 kernel
-    kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (3, 3))
-    dilated = cv2.dilate(alpha_np, kernel, iterations=1)
-    eroded = cv2.erode(alpha_np, kernel, iterations=1)
-    
-    outline = cv2.subtract(dilated, eroded)
-    
-    # Threshold to guarantee clean binary line
-    _, outline = cv2.threshold(outline, 127, 255, cv2.THRESH_BINARY)
-    
-    # Dilate the outline slightly to match the thicker Canny lines
-    outline_dilated = cv2.dilate(outline, kernel, iterations=1)
-    
-    return Image.fromarray(outline_dilated).convert("L")
+# Importa a função melhorada do seu módulo (que já está ajustado)
+from faceless_processing import build_faceless_embroidery_assets
 
 @spaces.GPU
 def process_faceless(input_image, prompt="", negative_prompt=""):
     if input_image is None:
         return None, None
-        
-    # Resize for speed and high-res lines consistency
-    w, h = input_image.size
-    max_dim = 800
-    if max(w, h) > max_dim:
-        if w > h:
-            new_w = max_dim
-            new_h = int(h * (max_dim / w))
-        else:
-            new_h = max_dim
-            new_w = int(w * (max_dim / h))
-        input_image = input_image.resize((new_w, new_h), Image.Resampling.LANCZOS)
-        
-    # 1. Remove background
-    subject = remove_background(input_image)
-    
-    # 2. Smoothly blur face regions (keeps eyebrows, removes eyes/mouth)
-    preprocessed, faces = blur_faces_smooth(subject)
-    
-    # 3. Extract line details using OpenCV Canny (thick, clean lines)
-    details_alpha = extract_fine_details_cv2(preprocessed, detail_profile="balanced")
-    
-    # 4. Generate outer silhouette outline
-    silhouette_alpha = generate_alpha_outline_cv2(subject.getchannel("A"))
-    
-    # 5. Combine outline and hair/body lineart details
-    combined_alpha = ImageChops.lighter(silhouette_alpha, details_alpha)
-    
-    # 6. Clean: mask lines with original subject alpha so no lines leak into transparency
-    subject_alpha = subject.getchannel("A")
-    combined_alpha = ImageChops.darker(combined_alpha, subject_alpha)
-    
-    # Create final transparent lineart image
-    lineart = Image.new("RGBA", combined_alpha.size, (0, 0, 0, 0))
-    lineart.putalpha(combined_alpha)
-    
-    # Cutout with smoothed alpha channel
-    cutout = subject.copy()
-    
-    return lineart, cutout
 
+    # NÃO REDIMENSIONAMOS A IMAGEM – a função interna já lida com tamanhos variados.
+    # Mas se quiser limitar por performance, pode redimensionar para no máximo 1024px
+    # (ainda mantendo qualidade para detecção facial).
+    # Vou deixar sem redimensionamento para máxima precisão.
+    
+    # Gera lineart e cutout usando a função otimizada
+    try:
+        lineart, cutout = build_faceless_embroidery_assets(
+            input_image,
+            use_huggingface=False,   # Desativa Hugging Face (pode ativar se tiver token)
+            prompt=prompt or None,
+            negative_prompt=negative_prompt or None,
+        )
+        return lineart, cutout
+    except Exception as e:
+        print(f"[ERRO] process_faceless: {e}")
+        # Fallback: retorna a imagem original e uma mensagem de erro
+        return input_image, None
+
+# Interface Gradio
 demo = gr.Interface(
     fn=process_faceless,
     inputs=[
@@ -196,8 +44,8 @@ demo = gr.Interface(
         gr.Image(label="Recorte do Rosto (Sem Fundo)")
     ],
     title="Faceless Embroidery Studio Generator",
-    description="Gera contornos e linearts minimalistas (Faceless) para bordados a partir de retratos."
+    description="Gera contornos e linearts minimalistas (Faceless) para bordados a partir de retratos.\n\n**Nota:** O rosto é completamente apagado e apenas a silhueta externa é desenhada."
 )
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch()