fixed errors

app.py

@@ -77,87 +77,184 @@ def apply_gaussian_blur_to_background(image_np, mask, sigma=15):
     return result
 
 # Normalize depth map
+# def normalize_depth_map(depth_map):
+#     depth_min = depth_map.min()
+#     depth_max = depth_map.max()
+#     normalized_depth = (depth_map - depth_min) / (depth_max - depth_min)
+#     return normalized_depth
+
 def normalize_depth_map(depth_map):
+    """Normalize depth map to range [0, 1]"""
     depth_min = depth_map.min()
     depth_max = depth_map.max()
+    if depth_min == depth_max:
+        return np.zeros_like(depth_map)  # Handle uniform depth
     normalized_depth = (depth_map - depth_min) / (depth_max - depth_min)
     return normalized_depth
 
 # Apply depth-based blur
+# def apply_depth_based_blur(image, depth_map, max_blur=25):
+#     # Create output image
+#     result = np.zeros_like(image)
+    
+#     # 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 = (depth_map <= blur_size / max_blur).astype(np.float32)
+#         else:
+#             lower_bound = (blur_size - 2) / max_blur
+#             upper_bound = blur_size / max_blur
+#             mask = ((depth_map > lower_bound) & (depth_map <= 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:
+#             blurred = cv2.GaussianBlur(image, (blur_size, blur_size), 0)
+#             mask_3d = np.stack([mask] * 3, axis=2)
+#             result += (blurred * mask_3d).astype(np.uint8)
+#         else:
+#             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"""
     # Create output image
     result = np.zeros_like(image)
     
+    # Normalize depth map
+    normalized_depth = normalize_depth_map(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 = (depth_map <= blur_size / max_blur).astype(np.float32)
+            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 = ((depth_map > lower_bound) & (depth_map <= upper_bound)).astype(np.float32)
+            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:
-            blurred = cv2.GaussianBlur(image, (blur_size, blur_size), 0)
-            mask_3d = np.stack([mask] * 3, axis=2)
-            result += (blurred * mask_3d).astype(np.uint8)
+        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
 
 # Process function for Gradio
-def process_image(input_image, blur_effect_type, blur_strength, target_class):
-    # Load models if not already loaded
-    if not hasattr(process_image, "models_loaded"):
-        process_image.segmenter, process_image.depth_estimator = load_models()
-        process_image.models_loaded = True
+# def process_image(input_image, blur_effect_type, blur_strength, target_class):
+#     # Load models if not already loaded
+#     if not hasattr(process_image, "models_loaded"):
+#         process_image.segmenter, process_image.depth_estimator = load_models()
+#         process_image.models_loaded = True
     
-    # Convert to numpy array
-    image_np = np.array(input_image)
+#     # Convert to numpy array
+#     image_np = np.array(input_image)
     
-    # Process based on selected effect
-    if blur_effect_type == "Gaussian Background Blur":
-        # Segment the image
-        segmentation_results = process_image.segmenter(input_image)
+#     # Process based on selected effect
+#     if blur_effect_type == "Gaussian Background Blur":
+#         # Segment the image
+#         segmentation_results = process_image.segmenter(input_image)
         
-        # Create binary mask
-        binary_mask = create_binary_mask(segmentation_results, image_np, target_class)
+#         # Create binary mask
+#         binary_mask = create_binary_mask(segmentation_results, image_np, target_class)
         
-        # Apply Gaussian blur to background
-        result = apply_gaussian_blur_to_background(image_np, binary_mask, sigma=blur_strength)
+#         # Apply Gaussian blur to background
+#         result = apply_gaussian_blur_to_background(image_np, binary_mask, sigma=blur_strength)
         
-        return result
+#         return result
         
-    elif blur_effect_type == "Depth-Based Lens Blur":
-        # Resize for depth estimation
-        depth_input = cv2.resize(image_np, (512, 512))
+#     elif blur_effect_type == "Depth-Based Lens Blur":
+#         # Resize for depth estimation
+#         depth_input = cv2.resize(image_np, (512, 512))
         
-        # Get depth map
-        depth_result = process_image.depth_estimator(depth_input)
-        depth_map = np.array(depth_result["depth"])
+#         # Get depth map
+#         depth_result = process_image.depth_estimator(depth_input)
+#         depth_map = np.array(depth_result["depth"])
         
-        # Normalize depth map
-        normalized_depth = normalize_depth_map(depth_map)
+#         # Normalize depth map
+#         normalized_depth = normalize_depth_map(depth_map)
         
-        # Apply depth-based blur
-        result = apply_depth_based_blur(depth_input, normalized_depth, max_blur=blur_strength)
+#         # Apply depth-based blur
+#         result = apply_depth_based_blur(depth_input, normalized_depth, max_blur=blur_strength)
         
-        # Resize back to original dimensions if needed
-        if image_np.shape[:2] != (512, 512):
-            result = cv2.resize(result, (image_np.shape[1], image_np.shape[0]))
+#         # Resize back to original dimensions if needed
+#         if image_np.shape[:2] != (512, 512):
+#             result = cv2.resize(result, (image_np.shape[1], image_np.shape[0]))
         
-        return result
+#         return result
     
-    else:
-        return image_np  # Return original if no effect selected
+#     else:
+#         return image_np  # Return original if no effect selected
+
+def process_image(input_image, blur_effect_type, blur_strength, target_class):
+    try:
+        # Load models if not already loaded
+        if not hasattr(process_image, "models_loaded"):
+            process_image.segmenter, process_image.depth_estimator = load_models()
+            process_image.models_loaded = True
+        
+        # Convert to numpy array
+        image_np = np.array(input_image)
+        
+        # Process based on selected effect
+        if blur_effect_type == "Gaussian Background Blur":
+            # Segment the image
+            segmentation_results = process_image.segmenter(input_image)
+            
+            # Create binary mask
+            binary_mask = create_binary_mask(segmentation_results, image_np, target_class)
+            
+            # Apply Gaussian blur to background
+            result = apply_gaussian_blur_to_background(image_np, binary_mask, sigma=blur_strength)
+            
+            return result
+            
+        elif blur_effect_type == "Depth-Based Lens Blur":
+            # Resize for depth estimation
+            depth_input = cv2.resize(image_np, (512, 512))
+            
+            # Get depth map
+            depth_result = process_image.depth_estimator(depth_input)
+            depth_map = np.array(depth_result["depth"])
+            
+            # Apply depth-based blur
+            result = apply_depth_based_blur(depth_input, depth_map, max_blur=blur_strength)
+            
+            # Resize back to original dimensions if needed
+            if image_np.shape[:2] != (512, 512):
+                result = cv2.resize(result, (image_np.shape[1], image_np.shape[0]))
+            
+            return result
+        
+        else:
+            return image_np  # Return original if no effect selected
+    
+    except Exception as e:
+        print(f"Error in process_image: {e}")
+        # Return the original image if there's an error
+        return input_image
+
 
 # Create Gradio interface
 demo = gr.Blocks(title="Image Blur Effects")
@@ -198,6 +295,8 @@ with demo:
         outputs=output_image
     )
     
+    error_output = gr.Textbox(label="Error Information", visible=False)
+    
     gr.Markdown("""
     ## How to use:
     1. Upload an image with a clear foreground subject
@@ -213,4 +312,4 @@ with demo:
 segmenter, depth_estimator = load_models()
 
 # Launch the app
-demo.launch()
+demo.launch(show_error = True)