Upload app.py

app.py

@@ -42,7 +42,6 @@ pipe = StableDiffusionXLInpaintPipeline.from_pretrained(
     use_safetensors=True
 )
 
-# Rimuovi il limitatore di sicurezza se crea problemi (opzionale)
 pipe.watermark = None 
 
 # ==============================================================================
@@ -77,7 +76,7 @@ STYLES = {
 # ==============================================================================
 
 def extract_head_crop(image_pil, face_bbox):
-    """Ritaglia un'area abbondante attorno al volto per catturare capelli e collo."""
+    """Ritaglia l'area della testa, fermandosi alla base del collo per escludere le spalle."""
     x1, y1, x2, y2 = face_bbox
     w = x2 - x1
     h = y2 - y1
@@ -88,66 +87,101 @@ def extract_head_crop(image_pil, face_bbox):
     crop_x1 = max(0, int(cx - crop_size/1.5))
     crop_y1 = max(0, int(cy - crop_size/1.2)) # Più spazio sopra per i capelli
     crop_x2 = min(image_pil.width, int(cx + crop_size/1.5))
-    crop_y2 = min(image_pil.height, int(cy + crop_size/2.5)) # Meno spazio sotto per evitare troppe spalle
+    
+    # Meno spazio sotto: fermiamoci alla base del collo, evitando le spalle
+    # y2 è circa il mento, y2 + h*0.5 è la fine del collo
+    crop_y2 = min(image_pil.height, int(y2 + h * 0.45)) 
     
     return image_pil.crop((crop_x1, crop_y1, crop_x2, crop_y2))
 
+def fade_bottom(image_rgba, fade_height_ratio=0.15):
+    """Applica una sfumatura trasparente alla base dell'immagine per fondere dolcemente il collo."""
+    width, height = image_rgba.size
+    fade_height = int(height * fade_height_ratio)
+    if fade_height == 0:
+        return image_rgba
+        
+    r, g, b, a = image_rgba.split()
+    alpha_np = np.array(a)
+    
+    # Crea un gradiente da 1.0 (opaco) a 0.0 (trasparente)
+    gradient = np.linspace(1, 0, fade_height)
+    gradient = np.tile(gradient[:, None], (1, width))
+    
+    # Applica il gradiente alla parte bassa del canale alpha
+    alpha_np[-fade_height:, :] = (alpha_np[-fade_height:, :] * gradient).astype(np.uint8)
+    
+    a = Image.fromarray(alpha_np)
+    image_rgba.putalpha(a)
+    return image_rgba
+
 @spaces.GPU(duration=60)
 def generate_avatar(user_image, selected_style):
     if user_image is None:
         raise gr.Error("Per favore, carica un'immagine del volto.")
 
-    # 1. Analisi del volto utente
+    # 1. Caricamento e analisi del Template (lo facciamo prima per sapere dove guarda)
+    style_config = STYLES[selected_style]
+    template_path = style_config["template"]
+    
+    if not os.path.exists(template_path):
+        raise gr.Error(f"Errore: il file di template {template_path} non esiste.")
+        
+    template_pil = Image.open(template_path).convert("RGB")
+    cv_template_image = cv2.cvtColor(np.array(template_pil), cv2.COLOR_RGB2BGR)
+    
+    template_faces = face_app.get(cv_template_image)
+    if len(template_faces) == 0:
+        raise gr.Error("Impossibile trovare un volto nel template di base.")
+    template_face = sorted(template_faces, key=lambda x: (x.bbox[2]-x.bbox[0])*(x.bbox[3]-x.bbox[1]))[-1]
+
+    # 2. Analisi iniziale del volto utente per controllare l'orientamento
     cv_user_image = cv2.cvtColor(np.array(user_image), cv2.COLOR_RGB2BGR)
     user_faces = face_app.get(cv_user_image)
     if len(user_faces) == 0:
         raise gr.Error("Nessun volto rilevato nella tua foto. Riprova con un selfie più chiaro.")
-    
     user_face = sorted(user_faces, key=lambda x: (x.bbox[2]-x.bbox[0])*(x.bbox[3]-x.bbox[1]))[-1]
 
-    # 2. Ritaglio e rimozione sfondo (Head Extraction)
+    # 3. Controllo Yaw (Orientamento Destra/Sinistra)
+    user_yaw = user_face.pose[1]
+    template_yaw = template_face.pose[1]
+    
+    # Se guardano in direzioni opposte, ribaltiamo il selfie
+    if (user_yaw * template_yaw) < 0:
+        print("Orientamenti opposti! Eseguo specchio (FLIP_LEFT_RIGHT) del selfie.")
+        user_image = user_image.transpose(Image.FLIP_LEFT_RIGHT)
+        # Rianalizziamo il volto ribaltato per avere le nuove coordinate perfette
+        cv_user_image = cv2.cvtColor(np.array(user_image), cv2.COLOR_RGB2BGR)
+        user_faces = face_app.get(cv_user_image)
+        user_face = sorted(user_faces, key=lambda x: (x.bbox[2]-x.bbox[0])*(x.bbox[3]-x.bbox[1]))[-1]
+
+    # 4. Ritaglio, rimozione sfondo e sfumatura collo
     print("Estrazione della testa con Rembg...")
     cropped_user = extract_head_crop(user_image, user_face.bbox)
     head_rgba = rembg.remove(cropped_user, session=rembg_session)
+    head_rgba = fade_bottom(head_rgba, fade_height_ratio=0.15) # Sfuma il collo
     
-    # 3. Analisi della testa scontornata per trovare le nuove coordinate del volto
+    # 5. Analisi della testa scontornata per trovare le nuove coordinate del volto
     head_rgb_cv = cv2.cvtColor(np.array(head_rgba.convert("RGB")), cv2.COLOR_RGB2BGR)
     head_faces = face_app.get(head_rgb_cv)
     if len(head_faces) == 0:
-        # Fallback se non trova il volto dopo il ritaglio
-        head_face = user_face
+        head_face_crop = user_face
     else:
-        head_face = sorted(head_faces, key=lambda x: (x.bbox[2]-x.bbox[0])*(x.bbox[3]-x.bbox[1]))[-1]
+        head_face_crop = sorted(head_faces, key=lambda x: (x.bbox[2]-x.bbox[0])*(x.bbox[3]-x.bbox[1]))[-1]
         
-    H_bbox = head_face.bbox
+    H_bbox = head_face_crop.bbox
     H_w = H_bbox[2] - H_bbox[0]
     H_h = H_bbox[3] - H_bbox[1]
     H_cx = H_bbox[0] + H_w/2
     H_cy = H_bbox[1] + H_h/2
-
-    # 4. Caricamento e analisi del Template
-    style_config = STYLES[selected_style]
-    template_path = style_config["template"]
-    
-    if not os.path.exists(template_path):
-        raise gr.Error(f"Errore: il file di template {template_path} non esiste.")
-        
-    template_pil = Image.open(template_path).convert("RGB")
-    cv_template_image = cv2.cvtColor(np.array(template_pil), cv2.COLOR_RGB2BGR)
-    
-    template_faces = face_app.get(cv_template_image)
-    if len(template_faces) == 0:
-        raise gr.Error("Impossibile trovare un volto nel template di base.")
-    template_face = sorted(template_faces, key=lambda x: (x.bbox[2]-x.bbox[0])*(x.bbox[3]-x.bbox[1]))[-1]
     
     T_bbox = template_face.bbox
     T_w = T_bbox[2] - T_bbox[0]
     T_cx = T_bbox[0] + T_w/2
     T_cy = T_bbox[1] + (T_bbox[3] - T_bbox[1])/2
 
-    # 5. Compositing (Incolla la testa sul template)
+    # 6. Compositing (Incolla la testa sul template)
     print("Compositing della testa sul template...")
-    # Scaliamo la testa in modo che la larghezza del volto coincida (con un piccolo margine in più per coprire bene)
     scale = (T_w / H_w) * 1.05 
     new_size = (int(head_rgba.width * scale), int(head_rgba.height * scale))
     scaled_head = head_rgba.resize(new_size, Image.LANCZOS)
@@ -161,14 +195,13 @@ def generate_avatar(user_image, selected_style):
     composited_pil = template_pil.copy()
     composited_pil.paste(scaled_head, (paste_x, paste_y), scaled_head)
     
-    # 6. Creazione della Maschera per l'Inpainting
+    # 7. Creazione della Maschera per l'Inpainting
     mask_pil = Image.new("L", composited_pil.size, 0)
     mask_pil.paste(scaled_head.split()[3], (paste_x, paste_y))
-    # Espandi leggermente la maschera per coprire bene i bordi e sfumala
     mask_pil = mask_pil.filter(ImageFilter.MaxFilter(7))
     mask_pil = mask_pil.filter(ImageFilter.GaussianBlur(15))
     
-    # 7. Stylization tramite Inpainting
+    # 8. Stylization tramite Inpainting
     repo_id = style_config["repo_id"]
     
     if repo_id:
@@ -186,7 +219,7 @@ def generate_avatar(user_image, selected_style):
         negative_prompt=style_config["negative_prompt"],
         image=composited_pil,
         mask_image=mask_pil,
-        strength=0.45, # Aumentato leggermente per permettere all'IA di ridisegnare capelli e occhiali nello stile
+        strength=0.45, 
         guidance_scale=8.0,
         num_inference_steps=35,
     ).images[0]