Update app.py

app.py

@@ -8,23 +8,41 @@ import time
 RESIZE_DIM = 512  # Resize images for faster processing
 
 # --- MediaPipe Initialization ---
-mp_face_mesh = mp.solutions.face_mesh
-face_mesh = mp_face_mesh.FaceMesh(
-    static_image_mode=True,      # Process static images
-    max_num_faces=1,             # Detect only one face for simplicity
-    refine_landmarks=True,       # Get more refined landmarks (lips, eyes, iris)
-    min_detection_confidence=0.5 # Default detection confidence
-)
+# Use try-except block for robustness if mediapipe is not installed correctly
+try:
+    mp_face_mesh = mp.solutions.face_mesh
+    face_mesh = mp_face_mesh.FaceMesh(
+        static_image_mode=True,      # Process static images
+        max_num_faces=1,             # Detect only one face for simplicity
+        refine_landmarks=True,       # Get more refined landmarks (lips, eyes, iris)
+        min_detection_confidence=0.5 # Default detection confidence
+    )
+    print("MediaPipe Face Mesh initialized successfully.")
+except AttributeError:
+    print("Error: Could not initialize MediaPipe Face Mesh. Is mediapipe installed correctly?")
+    # Provide a dummy object or exit if mediapipe is critical and missing
+    face_mesh = None # Or raise an exception
+
 
 # --- Helper Functions ---
 
 def get_landmarks(img):
     """Detects face landmarks using MediaPipe Face Mesh."""
     if img is None:
+        print("Warning: Input image is None in get_landmarks.")
+        return None
+    # Ensure mediapipe is available
+    if face_mesh is None:
+        print("Error: MediaPipe Face Mesh not available.")
         return None
 
     img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
-    results = face_mesh.process(img_rgb)
+    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:
         print("Warning: No face detected.")
@@ -32,11 +50,16 @@ def get_landmarks(img):
 
     # Assuming only one face
     landmarks_mp = results.multi_face_landmarks[0]
-    
+
     # Convert landmarks to numpy array of (x, y) coordinates
     h, w, _ = img.shape
-    landmarks = np.array([(int(pt.x * w), int(pt.y * h)) for pt in landmarks_mp.landmark], dtype=np.float32)
-    
+    landmarks = np.array([(pt.x * w, pt.y * h) for pt in landmarks_mp.landmark], dtype=np.float32)
+
+    # Check if landmarks are valid numbers (sometimes mediapipe might return NaN/inf?)
+    if not np.all(np.isfinite(landmarks)):
+        print("Warning: Invalid landmark coordinates detected (NaN/inf).")
+        return None
+
     # Add image corners as landmarks for better warping at edges
     corners = np.array([
         [0, 0],             # Top-left
@@ -44,45 +67,102 @@ def get_landmarks(img):
         [0, h - 1],         # Bottom-left
         [w - 1, h - 1]      # Bottom-right
     ], dtype=np.float32)
-    
-    landmarks = np.vstack((landmarks, corners))
-    
+
+    # Use vstack only if landmarks were successfully found
+    if landmarks.size > 0 :
+         landmarks = np.vstack((landmarks, corners))
+    else: # Should not happen if multi_face_landmarks check passed, but defensive coding
+         print("Warning: Landmarks array was empty unexpectedly.")
+         return None
+
+
     return landmarks
 
 def calculate_delaunay_triangles(rect, points):
     """Calculates Delaunay triangulation for a set of points."""
+    # Check for sufficient points
+    if points is None or len(points) < 3:
+        print("Warning: Not enough points for triangulation.")
+        return []
+
+    # Ensure points are finite
+    if not np.all(np.isfinite(points)):
+        print("Warning: Non-finite points passed to calculate_delaunay_triangles.")
+        # Attempt to filter out non-finite points
+        points = points[np.all(np.isfinite(points), axis=1)]
+        if len(points) < 3:
+             print("Warning: Not enough finite points left for triangulation.")
+             return []
+
+    # Ensure points are within reasonable bounds of the rect if possible
+    # This can prevent issues with Subdiv2D if coordinates are wildly off
+    points[:, 0] = np.clip(points[:, 0], rect[0], rect[0] + rect[2] - 1)
+    points[:, 1] = np.clip(points[:, 1], rect[1], rect[1] + rect[3] - 1)
+
+
     subdiv = cv2.Subdiv2D(rect)
-    for p in points:
-        # Subdiv2D expects tuple of integers
-        subdiv.insert((int(p[0]), int(p[1]))) 
+
+    # Create a point map *before* inserting for reliable index lookup
+    # Use tuple representation as dict keys
+    point_map = { (int(p[0]), int(p[1])): i for i, p in enumerate(points) }
+    inserted_points_map = {} # Keep track of points actually inserted
+
+    for i, p in enumerate(points):
+        point_tuple = (int(p[0]), int(p[1]))
+        # Avoid inserting duplicate points which can cause issues
+        if point_tuple not in inserted_points_map:
+            try:
+                subdiv.insert(point_tuple)
+                inserted_points_map[point_tuple] = i # Map inserted tuple back to original index
+            except cv2.error as e:
+                # This might happen if points are outside the rect despite clipping, or very close
+                print(f"Warning: Could not insert point {point_tuple} into Subdiv2D: {e}")
+                continue # Skip this point
+
 
     triangle_list = subdiv.getTriangleList()
 
     # Map triangle vertex coordinates back to indices in the points array
     delaunay_triangles = []
-    point_map = { (int(p[0]), int(p[1])): i for i, p in enumerate(points) }
+
 
     for t in triangle_list:
-        pt1 = (int(t[0]), int(t[1]))
-        pt2 = (int(t[2]), int(t[3]))
-        pt3 = (int(t[4]), int(t[5]))
-
-        # Check if triangle vertices are within the rectangle
-        if rect[0] <= pt1[0] < rect[0] + rect[2] and rect[1] <= pt1[1] < rect[1] + rect[3] and \
-           rect[0] <= pt2[0] < rect[0] + rect[2] and rect[1] <= pt2[1] < rect[1] + rect[3] and \
-           rect[0] <= pt3[0] < rect[0] + rect[2] and rect[1] <= pt3[1] < rect[1] + rect[3]:
-            
-            # Get indices of the points from the map
+        # Get points as tuples of integers
+        pt1_coord = (int(t[0]), int(t[1]))
+        pt2_coord = (int(t[2]), int(t[3]))
+        pt3_coord = (int(t[4]), int(t[5]))
+
+        pts_coords = [pt1_coord, pt2_coord, pt3_coord]
+
+        # Check if triangle vertices are within the rectangle (Subdiv2D can return triangles outside)
+        in_rect = all(
+            rect[0] <= p[0] < rect[0] + rect[2] and rect[1] <= p[1] < rect[1] + rect[3]
+            for p in pts_coords
+        )
+
+        if in_rect:
             indices = []
-            try:
-                indices.append(point_map[pt1])
-                indices.append(point_map[pt2])
-                indices.append(point_map[pt3])
-                delaunay_triangles.append(indices)
-            except KeyError:
-                # Skip triangles with vertices not in the original points list (can happen with subdiv)
-                # print(f"Skipping triangle with points: {pt1}, {pt2}, {pt3}")
-                pass
+            all_indices_found = True
+            for coord in pts_coords:
+                # Find the original index using the inserted_points_map
+                original_index = inserted_points_map.get(coord, None)
+                if original_index is not None:
+                    indices.append(original_index)
+                else:
+                    # This means a vertex coordinate returned by getTriangleList
+                    # doesn't match any *exactly* inserted point's integer tuple.
+                    # This can occasionally happen due to floating point inaccuracies or
+                    # if subdiv creates intermediate points. We should skip these triangles.
+                    # print(f"Warning: Could not map triangle vertex {coord} back to an original point index.")
+                    all_indices_found = False
+                    break # Stop processing this triangle
+
+            if all_indices_found and len(indices) == 3:
+                 # Check if we got 3 unique indices
+                 if len(set(indices)) == 3:
+                     delaunay_triangles.append(indices)
+                 # else:
+                     # print(f"Warning: Triangle mapping resulted in duplicate indices: {indices}")
 
 
     return delaunay_triangles
@@ -90,54 +170,103 @@ def calculate_delaunay_triangles(rect, points):
 
 def warp_triangle(img1, img2, t1, t2):
     """Warps a triangle from img1 to img2."""
-    # Find bounding box for each triangle
-    r1 = cv2.boundingRect(np.float32([t1]))
-    r2 = cv2.boundingRect(np.float32([t2]))
-
-    # Offset points by left-top corner of the respective rectangles
-    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)]
-    t2_rect_int = [(int(p[0]), int(p[1])) for p in t2_rect] # for fillConvexPoly
-
-    # Get mask by filling triangle
-    mask = np.zeros((r2[3], r2[2], 3), dtype=np.float32)
-    cv2.fillConvexPoly(mask, np.int32(t2_rect_int), (1.0, 1.0, 1.0), 16, 0)
-
-    # Crop image patch
-    img1_rect = img1[r1[1]:r1[1] + r1[3], r1[0]:r1[0] + r1[2]]
-    
-    # Handle cases where bounding box is empty or has zero dimension
-    if img1_rect.shape[0] == 0 or img1_rect.shape[1] == 0:
-        return # Skip this triangle if the source patch is invalid
-
-    size = (r2[2], r2[3])
-    # Affine Transform
-    warp_mat = cv2.getAffineTransform(np.float32(t1_rect), np.float32(t2_rect))
-    
-    # Apply Affine Transformation
-    img2_rect = cv2.warpAffine(img1_rect, warp_mat, size, None,
-                               flags=cv2.INTER_LINEAR, borderMode=cv2.BORDER_REFLECT_101)
-    
-    # Handle potential size mismatch after warpaffine if bounding boxes were different
-    h_mask, w_mask, _ = mask.shape
-    h_warp, w_warp, _ = img2_rect.shape
-    if h_mask != h_warp or w_mask != w_warp:
-       # print(f"Adjusting warp size {img2_rect.shape} to mask size {mask.shape}")
-       img2_rect = cv2.resize(img2_rect, (w_mask, h_mask))
-
-
-    # Apply mask
-    img2_rect = img2_rect * mask
-
-    # Copy triangular region to the output image
-    img2_part = img2[r2[1]:r2[1] + r2[3], r2[0]:r2[0] + r2[2]]
-    
-    # Ensure shapes match before blending
-    if img2_part.shape == img2_rect.shape:
-        img2[r2[1]:r2[1] + r2[3], r2[0]:r2[0] + r2[2]] = img2_part * (1.0 - mask) + img2_rect
-    # else:
-        # print(f"Shape mismatch during blend: {img2_part.shape} vs {img2_rect.shape}")
-        # Handle mismatch, e.g., by resizing or skipping the blend for this triangle
+    # Ensure triangles have 3 points
+    if len(t1) != 3 or len(t2) != 3:
+        print("Warning: Invalid triangle vertex count in warp_triangle.")
+        return
+
+    # Ensure points are finite
+    if not np.all(np.isfinite(t1)) or not np.all(np.isfinite(t2)):
+        print("Warning: Non-finite triangle vertices in warp_triangle.")
+        return
+
+    try:
+        # Find bounding box for each triangle
+        r1 = cv2.boundingRect(np.float32([t1]))
+        r2 = cv2.boundingRect(np.float32([t2]))
+
+        # Check for valid bounding boxes (width and height > 0)
+        if r1[2] <= 0 or r1[3] <= 0 or r2[2] <= 0 or r2[3] <= 0:
+            # print("Warning: Skipping triangle due to zero-area bounding box.")
+            return
+
+        # Offset points by left-top corner of the respective rectangles
+        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)]
+        t2_rect_int = [(int(p[0]), int(p[1])) for p in t2_rect] # for fillConvexPoly
+
+        # Get mask by filling triangle
+        mask = np.zeros((r2[3], r2[2], 3), dtype=np.float32)
+        cv2.fillConvexPoly(mask, np.int32(t2_rect_int), (1.0, 1.0, 1.0), 16, 0)
+
+        # Crop image patch
+        img1_rect = img1[r1[1]:r1[1] + r1[3], r1[0]:r1[0] + r1[2]]
+
+        # Handle cases where bounding box is empty or has zero dimension after slicing
+        if img1_rect.shape[0] == 0 or img1_rect.shape[1] == 0:
+            # print("Warning: Skipping triangle due to empty source patch after slicing.")
+            return # Skip this triangle if the source patch is invalid
+
+        size = (r2[2], r2[3])
+        # Affine Transform
+        warp_mat = cv2.getAffineTransform(np.float32(t1_rect), np.float32(t2_rect))
+
+        # Apply Affine Transformation
+        img2_rect = cv2.warpAffine(img1_rect, warp_mat, size, None,
+                                flags=cv2.INTER_LINEAR, borderMode=cv2.BORDER_REFLECT_101)
+
+        # Handle potential size mismatch after warpaffine if bounding boxes were different
+        h_mask, w_mask, _ = mask.shape
+        h_warp, w_warp, _ = img2_rect.shape
+        if h_mask != h_warp or w_mask != w_warp:
+            # print(f"Adjusting warp size {img2_rect.shape} to mask size {mask.shape}")
+            img2_rect = cv2.resize(img2_rect, (w_mask, h_mask))
+
+
+        # Apply mask
+        img2_rect = img2_rect * mask
+
+        # Copy triangular region to the output image
+        # Ensure destination slice indices are valid
+        y_start, y_end = r2[1], r2[1] + r2[3]
+        x_start, x_end = r2[0], r2[0] + r2[2]
+
+        # Clip indices to be within the bounds of img2
+        h_img2, w_img2, _ = img2.shape
+        y_start = max(0, y_start)
+        y_end = min(h_img2, y_end)
+        x_start = max(0, x_start)
+        x_end = min(w_img2, x_end)
+
+        # Adjust mask and warped rect if clipping occurred
+        off_y_start = y_start - r2[1]
+        off_y_end = off_y_start + (y_end - y_start)
+        off_x_start = x_start - r2[0]
+        off_x_end = off_x_start + (x_end - x_start)
+
+        # Check if the clipped area is valid
+        if off_y_end <= off_y_start or off_x_end <= off_x_start:
+            # print("Warning: Skipping triangle blend due to invalid clipped area.")
+            return
+
+        clipped_mask = mask[off_y_start:off_y_end, off_x_start:off_x_end]
+        clipped_img2_rect = img2_rect[off_y_start:off_y_end, off_x_start:off_x_end]
+
+
+        img2_part = img2[y_start:y_end, x_start:x_end]
+
+        # Ensure shapes match before blending
+        if img2_part.shape == clipped_img2_rect.shape and img2_part.shape == clipped_mask.shape:
+            img2[y_start:y_end, x_start:x_end] = img2_part * (1.0 - clipped_mask) + clipped_img2_rect
+        # else:
+            # This indicates an issue with clipping or resizing logic, should be investigated if it occurs often
+            # print(f"Shape mismatch during blend: Part={img2_part.shape}, Rect={clipped_img2_rect.shape}, Mask={clipped_mask.shape}")
+
+    except cv2.error as e:
+        print(f"OpenCV Error during warp_triangle (possibly degenerate triangle): {e}")
+    except Exception as e:
+        print(f"Unexpected error during warp_triangle: {e}")
+
 
 # --- Main Morphing Function ---
 
@@ -150,12 +279,21 @@ def morph_faces(img1_orig, img2_orig, alpha):
 
     # --- Input Validation and Preprocessing ---
     if img1_orig is None or img2_orig is None:
-        return img1_orig if img1_orig is not None else \
-               (np.zeros((RESIZE_DIM, RESIZE_DIM, 3), dtype=np.uint8) if img2_orig is None else cv2.resize(img2_orig, (RESIZE_DIM, RESIZE_DIM)))
+        print("Error: One or both input images are None in morph_faces.")
+        # Return a black image of standard size
+        black_img = np.zeros((RESIZE_DIM, RESIZE_DIM, 3), dtype=np.uint8)
+        return black_img
+
 
     # Resize images for consistency and speed
-    img1 = cv2.resize(img1_orig, (RESIZE_DIM, RESIZE_DIM))
-    img2 = cv2.resize(img2_orig, (RESIZE_DIM, RESIZE_DIM))
+    try:
+        img1 = cv2.resize(img1_orig, (RESIZE_DIM, RESIZE_DIM), interpolation=cv2.INTER_LINEAR)
+        img2 = cv2.resize(img2_orig, (RESIZE_DIM, RESIZE_DIM), interpolation=cv2.INTER_LINEAR)
+    except cv2.error as e:
+        print(f"Error resizing images: {e}")
+        black_img = np.zeros((RESIZE_DIM, RESIZE_DIM, 3), dtype=np.uint8)
+        return black_img # Return black image if resize fails
+
     h, w, _ = img1.shape
     rect = (0, 0, w, h) # Bounding rectangle for triangulation
 
@@ -163,12 +301,29 @@ def morph_faces(img1_orig, img2_orig, alpha):
     landmarks1 = get_landmarks(img1)
     landmarks2 = get_landmarks(img2)
 
-    if landmarks1 is None:
-        print("Error: Could not detect landmarks in Face 1.")
-        return img1 # Return original resized image 1
-    if landmarks2 is None:
-        print("Error: Could not detect landmarks in Face 2.")
-        return img2 # Return original resized image 2
+    # Handle landmark detection failure more robustly
+    if landmarks1 is None or landmarks2 is None:
+        print("Error: Landmark detection failed for one or both images. Blending directly.")
+        # Fallback: blend images directly (alpha blending)
+        try:
+            blended_img = cv2.addWeighted(img1, 1 - alpha, img2, alpha, 0)
+            return blended_img
+        except cv2.error as e:
+            print(f"Error during fallback alpha blending: {e}")
+            # If blending also fails, return one of the images or black
+            return img1 if landmarks1 is not None else (img2 if landmarks2 is not None else np.zeros_like(img1))
+
+
+    # Ensure landmarks have the same number of points before interpolation
+    if landmarks1.shape != landmarks2.shape:
+        print(f"Error: Landmark count mismatch! Img1: {landmarks1.shape}, Img2: {landmarks2.shape}. Blending directly.")
+        # Fallback: blend images directly
+        try:
+            blended_img = cv2.addWeighted(img1, 1 - alpha, img2, alpha, 0)
+            return blended_img
+        except cv2.error as e:
+             print(f"Error during fallback alpha blending after landmark mismatch: {e}")
+             return img1 # Or some default
 
     # --- Landmark Interpolation ---
     landmarks_morphed = (1 - alpha) * landmarks1 + alpha * landmarks2
@@ -176,54 +331,147 @@ def morph_faces(img1_orig, img2_orig, alpha):
 
     # --- Delaunay Triangulation (based on morphed landmarks) ---
     try:
-        triangles_indices = calculate_delaunay_triangles(rect, landmarks_morphed)
+        triangles_indices = calculate_delaunay_triangles(rect, landmarks_morphed.copy()) # Pass copy to avoid modification
         if not triangles_indices:
-            print("Error: Delaunay triangulation failed.")
+            print("Warning: Delaunay triangulation resulted in 0 triangles. Blending directly.")
             # Fallback: blend images directly
-            return cv2.addWeighted(img1, 1 - alpha, img2, alpha, 0)
+            blended_img = cv2.addWeighted(img1, 1 - alpha, img2, alpha, 0)
+            return blended_img
 
     except Exception as e:
-         print(f"Error during triangulation: {e}")
+         print(f"Error during triangulation: {e}. Blending directly.")
          # Fallback: blend images directly
-         return cv2.addWeighted(img1, 1 - alpha, img2, alpha, 0)
+         blended_img = cv2.addWeighted(img1, 1 - alpha, img2, alpha, 0)
+         return blended_img
 
 
     # --- Image Warping and Blending ---
-    morphed_img = np.zeros(img1.shape, dtype=img1.dtype)
-
     # Convert images to float32 for intermediate calculations to avoid overflow/clipping
-    img1_float = img1.astype(np.float32) / 255.0
-    img2_float = img2.astype(np.float32) / 255.0
+    # Handle potential conversion errors if images are not standard BGR uint8
+    try:
+        img1_float = img1.astype(np.float32) / 255.0
+        img2_float = img2.astype(np.float32) / 255.0
+    except ValueError as e:
+        print(f"Error converting images to float32: {e}. Returning img1.")
+        return img1
+
     morphed_img_float = np.zeros(img1.shape, dtype=np.float32)
 
 
     for indices in triangles_indices:
-        # Get vertices for each triangle
-        t1 = landmarks1[indices]
-        t2 = landmarks2[indices]
-        t_morphed = landmarks_morphed[indices]
-
-        # Warp triangles
-        img1_warped_tri = np.zeros_like(morphed_img_float)
-        img2_warped_tri = np.zeros_like(morphed_img_float)
-
-        warp_triangle(img1_float, img1_warped_tri, t1, t_morphed)
-        warp_triangle(img2_float, img2_warped_tri, t2, t_morphed)
+         # Check if indices are valid before accessing landmarks
+         if any(idx >= len(landmarks1) or idx < 0 for idx in indices):
+              print(f"Warning: Invalid triangle index found: {indices}. Max index: {len(landmarks1)-1}. Skipping triangle.")
+              continue
+
+         # Get vertices for each triangle
+         t1 = landmarks1[indices]
+         t2 = landmarks2[indices]
+         t_morphed = landmarks_morphed[indices]
+
+         # Warp triangles using the helper function that accumulates onto the final image
+         warp_triangle(img1_float, morphed_img_float, t1, (1-alpha) * t_morphed) # Warping img1 part
+         warp_triangle(img2_float, morphed_img_float, t2, alpha * t_morphed) # Warping img2 part
+         # Note: This simplified approach might lead to artifacts compared to warping both fully
+         #       and then alpha blending the warped results pixel-wise within the triangle mask.
+         #       Let's refine this part for better blending.
+
+    # --- Refined Image Warping and Blending (More Accurate) ---
+    morphed_img_float_refined = np.zeros(img1.shape, dtype=np.float32)
 
-        # Blend the warped triangles
-        morphed_triangle = (1 - alpha) * img1_warped_tri + alpha * img2_warped_tri
-
-        # Create mask for the morphed triangle to combine them
-        mask = np.zeros(morphed_img_float.shape[:2], dtype=np.float32)
-        cv2.fillConvexPoly(mask, t_morphed.astype(np.int32), 1, 16, 0)
-        mask = cv2.cvtColor(mask, cv2.COLOR_GRAY2BGR) # Make mask 3 channels
-
-        # Combine triangle into the final image
-        morphed_img_float = morphed_img_float * (1.0 - mask) + morphed_triangle * mask
+    for indices in triangles_indices:
+         if any(idx >= len(landmarks1) or idx < 0 for idx in indices):
+              # Already printed warning above
+              continue
+
+         t1 = landmarks1[indices]
+         t2 = landmarks2[indices]
+         t_morphed = landmarks_morphed[indices]
+
+         # Find bounding box for the morphed triangle
+         r_morphed = cv2.boundingRect(t_morphed)
+         x, y, w_box, h_box = r_morphed
+
+         # Check for valid box
+         if w_box <= 0 or h_box <= 0: continue
+
+         # Offset points
+         t_morphed_rect = [(t_morphed[i][0] - x, t_morphed[i][1] - y) for i in range(3)]
+         t1_rect = [(t1[i][0] - x, t1[i][1] - y) for i in range(3)] # Not really used this way, use full t1, t2 for getAffineTransform
+         t2_rect = [(t2[i][0] - x, t2[i][1] - y) for i in range(3)] # Not really used this way
+
+         # Create mask for the morphed triangle within its bounding box
+         mask = np.zeros((h_box, w_box), dtype=np.float32)
+         cv2.fillConvexPoly(mask, np.int32(t_morphed_rect), 1.0, 16, 0)
+         mask = cv2.cvtColor(mask, cv2.COLOR_GRAY2BGR) # Make 3 channels
+
+         # Warp source triangles TO the morphed triangle's bounding box shape
+         try:
+            warp_mat1 = cv2.getAffineTransform(np.float32(t1), np.float32(t_morphed))
+            warp_mat2 = cv2.getAffineTransform(np.float32(t2), np.float32(t_morphed))
+         except cv2.error:
+             # Likely degenerate triangle
+             continue # Skip this triangle
+
+         img1_warped = cv2.warpAffine(img1_float, warp_mat1, (w, h), None, flags=cv2.INTER_LINEAR, borderMode=cv2.BORDER_REFLECT_101)
+         img2_warped = cv2.warpAffine(img2_float, warp_mat2, (w, h), None, flags=cv2.INTER_LINEAR, borderMode=cv2.BORDER_REFLECT_101)
+
+         # Blend the FULL warped images
+         blended_warped = (1.0 - alpha) * img1_warped + alpha * img2_warped
+
+         # Extract the relevant bounding box from the blended warped image
+         blended_rect = blended_warped[y:y + h_box, x:x + w_box]
+
+         # Ensure mask and blended_rect sizes match before applying mask
+         if mask.shape != blended_rect.shape:
+             # This might happen if the bounding box calculated goes slightly out of bounds
+             # Resize mask or rect - resizing mask is safer. Let's try resizing rect if needed.
+             h_mask, w_mask, _ = mask.shape
+             blended_rect = cv2.resize(blended_rect, (w_mask, h_mask))
+             # print(f"Adjusting blended_rect size {blended_rect.shape} to mask size {mask.shape}")
+
+
+         # Combine using the mask within the bounding box of the final image
+         # Ensure destination slice indices are valid
+         y_start, y_end = y, y + h_box
+         x_start, x_end = x, x + w_box
+         # Clip indices to be within the bounds of the destination image
+         h_dest, w_dest, _ = morphed_img_float_refined.shape
+         y_start = max(0, y_start)
+         y_end = min(h_dest, y_end)
+         x_start = max(0, x_start)
+         x_end = min(w_dest, x_end)
+
+         # Calculate offsets for slicing the mask and blended_rect correctly
+         off_y_start = y_start - y
+         off_y_end = off_y_start + (y_end - y_start)
+         off_x_start = x_start - x
+         off_x_end = off_x_start + (x_end - x_start)
+
+         # Check if the clipped area is valid before slicing
+         if off_y_end <= off_y_start or off_x_end <= off_x_start:
+              continue
+
+         try:
+             clipped_mask = mask[off_y_start:off_y_end, off_x_start:off_x_end]
+             clipped_blended_rect = blended_rect[off_y_start:off_y_end, off_x_start:off_x_end]
+
+             dest_part = morphed_img_float_refined[y_start:y_end, x_start:x_end]
+
+             if dest_part.shape == clipped_blended_rect.shape and dest_part.shape == clipped_mask.shape:
+                 morphed_img_float_refined[y_start:y_end, x_start:x_end] = \
+                     dest_part * (1.0 - clipped_mask) + clipped_blended_rect * clipped_mask
+             # else:
+                 # print(f"Shape mismatch during refined blend: Dest={dest_part.shape}, Rect={clipped_blended_rect.shape}, Mask={clipped_mask.shape}")
+
+         except IndexError as e:
+             print(f"IndexError during refined blend slicing: {e}. Indices: y={y_start}:{y_end}, x={x_start}:{x_end}. Shapes: mask={mask.shape}, rect={blended_rect.shape}, refined={morphed_img_float_refined.shape}")
+         except Exception as e:
+              print(f"Unexpected error during refined blend: {e}")
 
 
     # Convert back to uint8
-    morphed_img = (morphed_img_float * 255.0).clip(0, 255).astype(np.uint8)
+    morphed_img = (morphed_img_float_refined * 255.0).clip(0, 255).astype(np.uint8)
 
     end_time = time.time()
     print(f"Morphing took: {end_time - start_time:.4f} seconds")
@@ -234,31 +482,44 @@ def morph_faces(img1_orig, img2_orig, alpha):
 
 def gradio_morph(image1, image2, transition_level):
     """Wrapper function for Gradio interface."""
+    print(f"Gradio inputs: img1 type={type(image1)}, img2 type={type(image2)}, transition={transition_level}")
+
+    # Check if inputs are valid numpy arrays
+    if image1 is None or not isinstance(image1, np.ndarray):
+        print("Input image 1 is missing or not a numpy array.")
+        image1 = None # Ensure it's None if invalid
+    if image2 is None or not isinstance(image2, np.ndarray):
+        print("Input image 2 is missing or not a numpy array.")
+        image2 = None # Ensure it's None if invalid
+
     # Map transition level (-1.0 to 1.0) to alpha (0.0 to 1.0)
     alpha = (transition_level + 1.0) / 2.0
-    
-    # Ensure alpha is exactly 0 or 1 at the extremes if needed, though float math should be close
-    alpha = max(0.0, min(1.0, alpha)) 
+    alpha = max(0.0, min(1.0, alpha)) # Clamp to [0, 1]
+
+    # Call the main morphing function
+    result_img = morph_faces(image1, image2, alpha)
 
-    if image1 is None or image2 is None:
-         return np.zeros((RESIZE_DIM, RESIZE_DIM, 3), dtype=np.uint8) # Return black image if inputs missing
+    # Ensure the output is always a valid numpy array for Gradio
+    if not isinstance(result_img, np.ndarray) or result_img.ndim != 3 or result_img.shape[2] != 3:
+        print(f"Warning: Output image is not a valid BGR numpy array (shape: {result_img.shape if isinstance(result_img, np.ndarray) else type(result_img)}). Returning black image.")
+        return np.zeros((RESIZE_DIM, RESIZE_DIM, 3), dtype=np.uint8)
 
-    return morph_faces(image1, image2, alpha)
+    return result_img
 
 # --- Gradio Interface Definition ---
 
 css = """
-img { object-fit: contain; } # Reduce image stretching in Gradio display
+img { object-fit: contain !important; }
 """
 
 with gr.Blocks(css=css) as iface:
     gr.Markdown("# Face Morphing App\nUpload two face images and adjust the slider to morph between them.")
-    
+
     with gr.Row():
-        with gr.Column():
+        with gr.Column(scale=1):
             img_input1 = gr.Image(type="numpy", label="Face 1", height=RESIZE_DIM, width=RESIZE_DIM)
             img_input2 = gr.Image(type="numpy", label="Face 2", height=RESIZE_DIM, width=RESIZE_DIM)
-        with gr.Column():
+        with gr.Column(scale=1):
             img_output = gr.Image(type="numpy", label="Morphed Face", height=RESIZE_DIM, width=RESIZE_DIM, interactive=False)
 
     slider = gr.Slider(
@@ -269,16 +530,28 @@ with gr.Blocks(css=css) as iface:
         label="Transition Level",
         info="Slide from -1.0 (Face 1) to 1.0 (Face 2)"
     )
-    
-    # Connect components
+
+    # --- CORRECTED EVENT WIRING ---
     inputs = [img_input1, img_input2, slider]
-    slider.release.then(fn=gradio_morph, inputs=inputs, outputs=img_output, show_progress="minimal")
+    # Trigger morph when slider is released OR when either image is changed/cleared
+    slider.release(fn=gradio_morph, inputs=inputs, outputs=img_output, show_progress="minimal")
     img_input1.change(fn=gradio_morph, inputs=inputs, outputs=img_output, show_progress="minimal")
     img_input2.change(fn=gradio_morph, inputs=inputs, outputs=img_output, show_progress="minimal")
+    # Also consider adding listeners for .clear() if needed
+    # img_input1.clear(fn=gradio_morph, inputs=inputs, outputs=img_output, show_progress="minimal")
+    # img_input2.clear(fn=gradio_morph, inputs=inputs, outputs=img_output, show_progress="minimal")
+
 
     gr.Markdown("---")
     gr.Markdown("Built with Gradio, OpenCV, and MediaPipe.")
 
 # --- Launch the App ---
 if __name__ == "__main__":
-    iface.launch()
+    if face_mesh is None:
+         print("\nERROR: MediaPipe could not be initialized. The application cannot run.")
+         print("Please ensure the 'mediapipe' library is installed correctly (`pip install mediapipe`).")
+    else:
+        print("\nLaunching Gradio Interface...")
+        # Add share=True if you want to create a public link (requires internet)
+        # Add debug=True for more detailed Gradio logs if needed
+        iface.launch()