Update app.py

app.py

@@ -7,12 +7,15 @@ import tempfile
 import os
 
 # --- MediaPipe Initialization ---
+# Use try-except block for robustness if mediapipe is not installed correctly
 try:
     mp_face_mesh = mp.solutions.face_mesh
+    # NOTE: refine_landmarks=True gives 478 landmarks. False gives 468.
+    # We will control density by sub-sampling rather than this boolean for more control.
     face_mesh = mp_face_mesh.FaceMesh(
         static_image_mode=True,
         max_num_faces=1,
-        refine_landmarks=True,
+        refine_landmarks=True, # Keep this on for the best potential quality
         min_detection_confidence=0.5
     )
     print("MediaPipe Face Mesh initialized successfully.")
@@ -20,7 +23,7 @@ except (ImportError, AttributeError):
     print("Error: Could not initialize MediaPipe Face Mesh. Is mediapipe installed correctly?")
     face_mesh = None
 
-# --- Helper Functions (No changes in these three) ---
+# --- Helper Functions ---
 
 def get_landmarks(img, landmark_step=1):
     """
@@ -28,33 +31,54 @@ def get_landmarks(img, landmark_step=1):
     Includes sub-sampling for performance.
     - landmark_step: Step to sample landmarks. 1 = all, 2 = half, etc.
     """
-    if img is None: return None
-    if face_mesh is None: return None
+    if img is None:
+        print("Warning: Input image is None in get_landmarks.")
+        return None
+    if face_mesh is None:
+        print("Error: MediaPipe Face Mesh not available.")
+        return None
+
     img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
     try:
         results = face_mesh.process(img_rgb)
     except Exception as e:
         print(f"Error processing image with MediaPipe: {e}")
         return None
-    if not results.multi_face_landmarks: return None
+
+    if not results.multi_face_landmarks:
+        print("Warning: No face detected.")
+        return None
 
     landmarks_mp = results.multi_face_landmarks[0]
     h, w, _ = img.shape
+    
+    # Get all landmarks first
     full_landmarks = np.array([(pt.x * w, pt.y * h) for pt in landmarks_mp.landmark], dtype=np.float32)
 
+    # --- NEW: Sub-sample landmarks for speed ---
     if landmark_step > 1:
+        # Sample with a step, ensuring correspondence is maintained between faces
         landmarks = full_landmarks[::landmark_step]
     else:
         landmarks = full_landmarks
 
-    if not np.all(np.isfinite(landmarks)): return None
-    corners = np.array([[0, 0], [w - 1, 0], [0, h - 1], [w - 1, h - 1]], dtype=np.float32)
+    if not np.all(np.isfinite(landmarks)):
+        print("Warning: Invalid landmark coordinates detected (NaN/inf).")
+        return None
+
+    corners = np.array([
+        [0, 0], [w - 1, 0], [0, h - 1], [w - 1, h - 1]
+    ], dtype=np.float32)
+    
+    # Always include corners for stable warping
     landmarks = np.vstack((landmarks, corners))
+
     return landmarks
 
 def calculate_delaunay_triangles(rect, points):
-    """Calculates Delaunay triangulation for a set of points."""
-    if points is None or len(points) < 3: return []
+    """Calculates Delaunay triangulation for a set of points. (No changes needed here)"""
+    if points is None or len(points) < 3:
+        return []
     if not np.all(np.isfinite(points)):
         points = points[np.all(np.isfinite(points), axis=1)]
         if len(points) < 3: return []
@@ -65,13 +89,15 @@ def calculate_delaunay_triangles(rect, points):
     subdiv = cv2.Subdiv2D(rect)
     point_map = { (int(p[0]), int(p[1])): i for i, p in enumerate(points) }
     inserted_points_map = {}
+
     for i, p in enumerate(points):
         point_tuple = (int(p[0]), int(p[1]))
         if point_tuple not in inserted_points_map:
             try:
                 subdiv.insert(point_tuple)
                 inserted_points_map[point_tuple] = i
-            except cv2.error: continue
+            except cv2.error:
+                continue
     
     triangle_list = subdiv.getTriangleList()
     delaunay_triangles = []
@@ -83,29 +109,41 @@ def calculate_delaunay_triangles(rect, points):
                 delaunay_triangles.append(indices)
     return delaunay_triangles
 
+
 def warp_triangle(img1, img2, t1, t2):
-    """Warps a triangle from img1 to img2."""
-    if len(t1) != 3 or len(t2) != 3 or not np.all(np.isfinite(t1)) or not np.all(np.isfinite(t2)): return
+    """Warps a triangle from img1 to img2. (No changes needed here)"""
+    if len(t1) != 3 or len(t2) != 3 or not np.all(np.isfinite(t1)) or not np.all(np.isfinite(t2)):
+        return
     try:
         r1 = cv2.boundingRect(np.float32([t1]))
         r2 = cv2.boundingRect(np.float32([t2]))
+
         if r1[2] <= 0 or r1[3] <= 0 or r2[2] <= 0 or r2[3] <= 0: return
+
         t1_rect = [(t1[i][0] - r1[0], t1[i][1] - r1[1]) for i in range(3)]
         t2_rect = [(t2[i][0] - r2[0], t2[i][1] - r2[1]) for i in range(3)]
+
         mask = np.zeros((r2[3], r2[2], 3), dtype=np.float32)
         cv2.fillConvexPoly(mask, np.int32(t2_rect), (1.0, 1.0, 1.0), 16, 0)
+        
         img1_rect = img1[r1[1]:r1[1] + r1[3], r1[0]:r1[0] + r1[2]]
         if img1_rect.size == 0: return
+
         size = (r2[2], r2[3])
         warp_mat = cv2.getAffineTransform(np.float32(t1_rect), np.float32(t2_rect))
         img2_rect = cv2.warpAffine(img1_rect, warp_mat, size, None, flags=cv2.INTER_LINEAR, borderMode=cv2.BORDER_REFLECT_101)
+
         img2_rect *= mask
+        
         y_start, y_end = r2[1], r2[1] + r2[3]
         x_start, x_end = r2[0], r2[0] + r2[2]
+        
         h_img2, w_img2, _ = img2.shape
         if y_start >= h_img2 or x_start >= w_img2: return
+
         img2[y_start:y_end, x_start:x_end] = img2[y_start:y_end, x_start:x_end] * (1.0 - mask) + img2_rect
-    except (cv2.error, IndexError): pass
+    except (cv2.error, IndexError):
+        pass # Ignore degenerate triangles or slicing errors
 
 # --- Main Morphing Function (Modified) ---
 def morph_faces(img1_orig, img2_orig, alpha, resize_dim, landmark_step):
@@ -180,31 +218,45 @@ def morph_faces(img1_orig, img2_orig, alpha, resize_dim, landmark_step):
     print(f"Frame morph ({w}x{h}, {len(landmarks1)} landmarks) took: {end_time - start_time:.4f}s")
     return morphed_img
 
-    
 # --- Video Processing Function (Modified) ---
-def process_video(video_path, target_img, transition_level, resolution, landmark_sampling, show_triangles):
+def process_video(video_path, target_img, transition_level, resolution, landmark_sampling):
     """
-    Callback function that now receives show_triangles from the UI.
+    Callback function that now receives resolution and landmark settings from the UI.
     """
     if video_path is None or target_img is None:
+        # Create a dummy video to avoid Gradio errors on empty inputs
         dummy_path = tempfile.NamedTemporaryFile(delete=False, suffix=".mp4").name
-        out = cv2.VideoWriter(dummy_path, cv2.VideoWriter_fourcc(*'mp4v'), 24, (resolution, resolution))
+        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+        out = cv2.VideoWriter(dummy_path, fourcc, 24, (resolution, resolution))
         out.release()
         return dummy_path
 
     alpha = (transition_level + 1.0) / 2.0
+    alpha = float(np.clip(alpha, 0.0, 1.0))
+
     cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened():
+        raise IOError(f"Cannot open video file: {video_path}")
+    
     fps = cap.get(cv2.CAP_PROP_FPS) or 24
+    fourcc = cv2.VideoWriter_fourcc(*"mp4v")
     tmp_out = tempfile.NamedTemporaryFile(delete=False, suffix=".mp4")
-    out = cv2.VideoWriter(tmp_out.name, cv2.VideoWriter_fourcc(*"mp4v"), fps, (resolution, resolution))
+    
+    # --- Use dynamic resolution for the output video ---
+    out = cv2.VideoWriter(tmp_out.name, fourcc, fps, (resolution, resolution))
 
+    frame_count = 0
     while True:
         ret, frame = cap.read()
-        if not ret: break
-        # Pass the show_triangles flag to the morphing function
-        morphed = morph_faces(frame, target_img, alpha, resolution, landmark_sampling, show_triangles)
+        if not ret:
+            break
+        
+        # Pass the new parameters to the morphing function
+        morphed = morph_faces(frame, target_img, alpha, resolution, landmark_sampling)
         out.write(morphed)
+        frame_count += 1
     
+    print(f"Processed {frame_count} frames.")
     cap.release()
     out.release()
     return tmp_out.name
@@ -219,18 +271,28 @@ with gr.Blocks(css=css) as iface:
         img_input = gr.Image(type="numpy", label="Target Face Image")
     
     with gr.Row():
-        resolution_slider = gr.Dropdown([256, 384, 512, 768], value=512, label="Processing Resolution")
-        landmark_slider = gr.Slider(1, 4, value=1, step=1, label="Landmark Sub-sampling", info="1=Max Quality, 4=Max Speed")
-        
+        # --- NEW: UI controls for performance ---
+        resolution_slider = gr.Dropdown(
+            [256, 384, 512, 768], 
+            value=512, 
+            label="Processing Resolution",
+            info="Lower resolution means much faster processing."
+        )
+        landmark_slider = gr.Slider(
+            1, 4, 
+            value=1, 
+            step=1, 
+            label="Landmark Sub-sampling",
+            info="1=Max Quality (~478 landmarks), 4=Max Speed (~120 landmarks)"
+        )
+
     slider = gr.Slider(-1.0, 1.0, value=0.0, step=0.05, label="Transition Level (-1 = Video, 1 = Image)")
-    
-    # --- NEW: Checkbox for triangulation lines ---
-    triangles_checkbox = gr.Checkbox(label="Show Triangulation Lines", value=False)
-    
     video_output = gr.Video(label="Morphed Video")
 
-    inputs = [video_input, img_input, slider, resolution_slider, landmark_slider, triangles_checkbox]
+    # Gather all input components
+    inputs = [video_input, img_input, slider, resolution_slider, landmark_slider]
 
+    # Trigger processing on any input change
     for component in inputs:
         component.change(
             fn=process_video,