final touches added

app.py

@@ -82,54 +82,95 @@ def normalize_depth_map(depth_map):
     depth_min = depth_map.min()
     depth_max = depth_map.max()
     if depth_min == depth_max:
-        return np.zeros_like(depth_map)  # Handle uniform depth
+        return np.zeros_like(depth_map)
     normalized_depth = (depth_map - depth_min) / (depth_max - depth_min)
-    return normalized_depth
+    # Explicitly invert the depth map - this is the critical fix
+    return 1.0 - normalized_depth
 
 # Apply depth-based blur
+# def apply_depth_based_blur(image, depth_map, max_blur=25):
+#     """Apply variable Gaussian blur based on depth with enhanced effect"""
+#     # Create output image
+#     result = np.zeros_like(image)
+    
+#     # Normalize depth map
+#     normalized_depth = normalize_depth_map(depth_map)
+    
+#     # Enhance depth contrast to make the effect more noticeable
+#     # Apply gamma correction to increase contrast between foreground and background
+#     gamma = 0.5  # Values less than 1 will enhance contrast
+#     normalized_depth = np.power(normalized_depth, gamma)
+    
+#     # Apply blur with intensity proportional to depth
+#     for blur_size in range(1, max_blur + 1, 2):  # Odd numbers for kernel size
+#         # Create a mask for pixels that should receive this blur level
+#         if blur_size == 1:
+#             mask = (normalized_depth <= blur_size / max_blur).astype(np.float32)
+#         else:
+#             lower_bound = (blur_size - 2) / max_blur
+#             upper_bound = blur_size / max_blur
+#             mask = ((normalized_depth > lower_bound) & (normalized_depth <= upper_bound)).astype(np.float32)
+        
+#         # Skip if no pixels in this range
+#         if not np.any(mask):
+#             continue
+        
+#         # Apply Gaussian blur with current kernel size
+#         if blur_size > 1:  # No need to blur with kernel size 1
+#             try:
+#                 blurred = cv2.GaussianBlur(image, (blur_size, blur_size), 0)
+#                 # Add blurred result to output image
+#                 mask_3d = np.stack([mask] * 3, axis=2)
+#                 result += (blurred * mask_3d).astype(np.uint8)
+#             except Exception as e:
+#                 print(f"Error applying blur with size {blur_size}: {e}")
+#                 continue
+#         else:
+#             # For blur_size=1, just copy the original pixels
+#             mask_3d = np.stack([mask] * 3, axis=2)
+#             result += (image * mask_3d).astype(np.uint8)
+    
+#     return result
+
 def apply_depth_based_blur(image, depth_map, max_blur=25):
-    """Apply variable Gaussian blur based on depth with enhanced effect"""
-    # Create output image
-    result = np.zeros_like(image)
+    """Apply variable Gaussian blur based on depth with foreground in focus"""
+    # Start with a copy of the original image
+    result = image.copy().astype(float)
     
     # Normalize depth map
     normalized_depth = normalize_depth_map(depth_map)
     
-    # Enhance depth contrast to make the effect more noticeable
-    # Apply gamma correction to increase contrast between foreground and background
-    gamma = 0.5  # Values less than 1 will enhance contrast
-    normalized_depth = np.power(normalized_depth, gamma)
+    # The depth map from intel/dpt-large is already set up so closer objects 
+    # have lower values. We need to define a threshold to separate foreground from background.
+    foreground_threshold = 0.3  # Adjust this value based on your depth map
     
-    # Apply blur with intensity proportional to depth
-    for blur_size in range(1, max_blur + 1, 2):  # Odd numbers for kernel size
-        # Create a mask for pixels that should receive this blur level
-        if blur_size == 1:
-            mask = (normalized_depth <= blur_size / max_blur).astype(np.float32)
-        else:
-            lower_bound = (blur_size - 2) / max_blur
-            upper_bound = blur_size / max_blur
-            mask = ((normalized_depth > lower_bound) & (normalized_depth <= upper_bound)).astype(np.float32)
-        
-        # Skip if no pixels in this range
-        if not np.any(mask):
-            continue
-        
-        # Apply Gaussian blur with current kernel size
-        if blur_size > 1:  # No need to blur with kernel size 1
-            try:
-                blurred = cv2.GaussianBlur(image, (blur_size, blur_size), 0)
-                # Add blurred result to output image
-                mask_3d = np.stack([mask] * 3, axis=2)
-                result += (blurred * mask_3d).astype(np.uint8)
-            except Exception as e:
-                print(f"Error applying blur with size {blur_size}: {e}")
+    # Create increasingly blurred versions of the image
+    blurred_images = []
+    blur_strengths = []
+    
+    # Generate progressively blurred versions
+    for blur_size in range(3, max_blur + 1, 4):  # Use larger step for efficiency
+        blur_strengths.append(blur_size)
+        blurred = cv2.GaussianBlur(image, (blur_size, blur_size), 0)
+        blurred_images.append(blurred)
+    
+    # Apply the appropriate blur level based on depth
+    for y in range(image.shape[0]):
+        for x in range(image.shape[1]):
+            depth_val = normalized_depth[y, x]
+            
+            # Keep foreground sharp
+            if depth_val <= foreground_threshold:
                 continue
-        else:
-            # For blur_size=1, just copy the original pixels
-            mask_3d = np.stack([mask] * 3, axis=2)
-            result += (image * mask_3d).astype(np.uint8)
+                
+            # Apply blur based on depth - background gets more blur
+            relative_depth = (depth_val - foreground_threshold) / (1 - foreground_threshold)
+            blur_index = min(int(relative_depth * len(blurred_images)), len(blurred_images) - 1)
+            
+            # Apply the appropriate blur level
+            result[y, x] = blurred_images[blur_index][y, x]
     
-    return result
+    return result.astype(np.uint8)
 
 
 # Process function for Gradio