Update app.py

app.py

@@ -1,5 +1,5 @@
 # =========================
-# app.py  (Enhanced Version with Lip-Sync Optimization)
+# app.py  (Fixed Version - No More Lip Glitches)
 # =========================
 import os
 
@@ -228,7 +228,7 @@ def _cv2_to_pil(image):
 def _pil_to_cv2(image):
     return cv2.cvtColor(np.array(image), cv2.COLOR_RGB2BGR)
 
-# Enhanced face blending function with mouth protection
+# Fixed face blending function
 def _blend_faces(original_face, swapped_face, blend_percent, mouth_mask=None):
     """Blend between original and swapped faces with optional mouth protection"""
     if blend_percent == 100:
@@ -241,27 +241,20 @@ def _blend_faces(original_face, swapped_face, blend_percent, mouth_mask=None):
     alpha = blend_percent / 100.0
     
     if mouth_mask is not None:
-        # Apply different blending for mouth vs non-mouth regions
+        # Ensure mask matches dimensions
         if mouth_mask.shape[:2] != original_face.shape[:2]:
             mouth_mask = cv2.resize(mouth_mask, (original_face.shape[1], original_face.shape[0]))
         
-        # Stronger blending for non-mouth areas, preserve mouth more
-        mouth_alpha = min(alpha + 0.2, 1.0)  # Less blending in mouth area
-        blended = np.zeros_like(original_face)
+        # Normalize mask to 0-1 range
+        mouth_mask_float = mouth_mask.astype(np.float32) / 255.0
+        if len(mouth_mask_float.shape) == 2:
+            mouth_mask_float = np.repeat(mouth_mask_float[:, :, np.newaxis], 3, axis=2)
         
-        # Mouth area - more preservation of swapped face
-        blended[mouth_mask > 0] = cv2.addWeighted(
-            swapped_face[mouth_mask > 0], mouth_alpha,
-            original_face[mouth_mask > 0], 1 - mouth_alpha, 0
-        )
-        
-        # Non-mouth area - normal blending
-        blended[mouth_mask == 0] = cv2.addWeighted(
-            swapped_face[mouth_mask == 0], alpha,
-            original_face[mouth_mask == 0], 1 - alpha, 0
-        )
+        # Apply blending with mask
+        blended = swapped_face * mouth_mask_float + original_face * (1 - mouth_mask_float)
+        blended = blended * alpha + original_face * (1 - alpha)
         
-        return blended
+        return blended.astype(np.uint8)
     else:
         # Standard blending if no mouth mask
         return cv2.addWeighted(swapped_face, alpha, original_face, 1 - alpha, 0)
@@ -278,7 +271,6 @@ def _create_mouth_mask(face_landmarks, image_shape, strength=80):
     
     # Mouth landmark indices (approximate for 106-point model)
     mouth_indices = list(range(48, 68))  # Lips outline
-    mouth_inner = list(range(60, 68))    # Inner mouth
     
     if len(landmarks) < 68:
         return None
@@ -291,17 +283,11 @@ def _create_mouth_mask(face_landmarks, image_shape, strength=80):
         hull = cv2.convexHull(mouth_points)
         cv2.fillPoly(mask, [hull], 255)
     
-    # Add inner mouth with lower strength
-    inner_points = np.array([landmarks[i] for i in mouth_inner], dtype=np.int32)
-    if len(inner_points) > 2:
-        inner_hull = cv2.convexHull(inner_points)
-        cv2.fillPoly(mask, [inner_hull], 200)  # Lower value for inner area
-    
     # Apply Gaussian blur for smooth edges
-    mask = cv2.GaussianBlur(mask, (15, 15), 0)
+    mask = cv2.GaussianBlur(mask, (21, 21), 0)
     
     # Adjust based on strength parameter
-    mask = cv2.addWeighted(mask, strength/100.0, np.zeros_like(mask), 0, 0)
+    mask = np.clip(mask * (strength / 100.0), 0, 255).astype(np.uint8)
     
     return mask
 
@@ -325,7 +311,7 @@ def _select_face(faces, method, image_shape=None):
         return faces[0]
 
 # -------------------------------------
-# Core: Enhanced face swap functions with lip-sync optimization
+# Core: FIXED face swap functions
 # -------------------------------------
 def swap_faces_in_image(
     source_image_bgr, target_image_bgr, proc_res, max_faces, 
@@ -370,21 +356,22 @@ def swap_faces_in_image(
             st.warning("⚠️ No faces detected in the target image.")
             return _cv2_to_pil(target_image_bgr)
 
-        # Limit faces to largest N
+        # Limit faces to largest N with quality filtering
         target_faces = sorted(
             target_faces,
             key=lambda f: (f.bbox[2]-f.bbox[0])*(f.bbox[3]-f.bbox[1]),
             reverse=True
-        )[:max_faces]
+        )
+        target_faces = [f for f in target_faces if f.det_score > 0.5][:max_faces]
 
         # Swap faces with lip-sync optimization
         result_image = target_image_proc.copy()
         for tface in target_faces:
             try:
-                # Get face bounding box
+                # Get face bounding box with padding
                 x1, y1, x2, y2 = [int(coord) for coord in tface.bbox]
-                x1, y1 = max(0, x1), max(0, y1)
-                x2, y2 = min(result_image.shape[1], x2), min(result_image.shape[0], y2)
+                x1, y1 = max(0, x1-10), max(0, y1-10)  # Add padding
+                x2, y2 = min(result_image.shape[1], x2+10), min(result_image.shape[0], y2+10)
                 
                 # Skip if invalid bbox
                 if x2 <= x1 or y2 <= y1:
@@ -398,12 +385,11 @@ def swap_faces_in_image(
                 if lip_sync_enabled and hasattr(tface, 'landmark_2d_106'):
                     mouth_mask = _create_mouth_mask(tface, face_region.shape, mouth_mask_strength)
                 
-                # Perform the swap
-                swapped_region = swapper.get(result_image, tface, source_face, paste_back=True)
-                swapped_face = swapped_region[y1:y2, x1:x2]
+                # FIXED: Process only the face region, not the whole image
+                swapped_face_region = swapper.get(face_region, tface, source_face, paste_back=False)
                 
                 # Apply blending with mouth protection
-                blended_face = _blend_faces(face_region, swapped_face, blend_percent, mouth_mask)
+                blended_face = _blend_faces(face_region, swapped_face_region, blend_percent, mouth_mask)
                 result_image[y1:y2, x1:x2] = blended_face
                     
             except Exception as swap_e:
@@ -508,10 +494,9 @@ def swap_faces_in_video(
                 except Exception as det_e:
                     target_faces = []
 
-                # Apply frame consistency
-                if frame_consistency > 0 and previous_faces and target_faces:
-                    target_faces = _apply_frame_consistency(target_faces, previous_faces, frame_consistency/100.0)
-
+                # Quality filtering
+                target_faces = [f for f in target_faces if f.det_score > 0.6]
+                
                 # Limit faces
                 if target_faces:
                     target_faces = sorted(
@@ -519,16 +504,15 @@ def swap_faces_in_video(
                         key=lambda f: (f.bbox[2]-f.bbox[0])*(f.bbox[3]-f.bbox[1]),
                         reverse=True
                     )[:max_faces]
-                    previous_faces = {i: face for i, face in enumerate(target_faces)}
 
                 # Swap faces with lip-sync optimization
                 result_frame = proc_frame.copy()
                 for tface in target_faces:
                     try:
-                        # Get face bounding box
+                        # Get face bounding box with padding
                         x1, y1, x2, y2 = [int(coord) for coord in tface.bbox]
-                        x1, y1 = max(0, x1), max(0, y1)
-                        x2, y2 = min(result_frame.shape[1], x2), min(result_frame.shape[0], y2)
+                        x1, y1 = max(0, x1-15), max(0, y1-15)
+                        x2, y2 = min(result_frame.shape[1], x2+15), min(result_frame.shape[0], y2+15)
                         
                         # Skip if invalid bbox
                         if x2 <= x1 or y2 <= y1:
@@ -542,12 +526,11 @@ def swap_faces_in_video(
                         if lip_sync_enabled and hasattr(tface, 'landmark_2d_106'):
                             mouth_mask = _create_mouth_mask(tface, face_region.shape, mouth_mask_strength)
                         
-                        # Perform the swap
-                        swapped_region = swapper.get(result_frame, tface, source_face, paste_back=True)
-                        swapped_face = swapped_region[y1:y2, x1:x2]
+                        # FIXED: Process only the face region
+                        swapped_face_region = swapper.get(face_region, tface, source_face, paste_back=False)
                         
                         # Apply blending with mouth protection
-                        blended_face = _blend_faces(face_region, swapped_face, blend_percent, mouth_mask)
+                        blended_face = _blend_faces(face_region, swapped_face_region, blend_percent, mouth_mask)
                         result_frame[y1:y2, x1:x2] = blended_face
                             
                     except Exception as swap_e:
@@ -582,25 +565,6 @@ def swap_faces_in_video(
 
     return output_path
 
-def _apply_frame_consistency(current_faces, previous_faces, consistency_strength):
-    """Maintain consistency between frames for smoother video"""
-    if not current_faces or not previous_faces:
-        return current_faces
-    
-    consistent_faces = []
-    for i, current_face in enumerate(current_faces):
-        if i in previous_faces:
-            # Blend current face with previous face for consistency
-            prev_face = previous_faces[i]
-            # Simple position smoothing (you can add more sophisticated blending)
-            current_face.bbox = [
-                prev_face.bbox[j] * consistency_strength + current_face.bbox[j] * (1 - consistency_strength)
-                for j in range(4)
-            ]
-        consistent_faces.append(current_face)
-    
-    return consistent_faces
-
 # -------------------------
 # UI: Improved layout
 # -------------------------