Update to add synthetic blur

app.py

@@ -21,7 +21,6 @@ def gaussian_blur(img: Image.Image, kernel_size: int):
     return cv2.cvtColor(blurred, cv2.COLOR_BGR2RGB)
 
 
-# Load model once globally
 depth_model_id = "depth-anything/Depth-Anything-V2-Small-hf"
 processor = AutoImageProcessor.from_pretrained(depth_model_id)
 depth_model = AutoModelForDepthEstimation.from_pretrained(depth_model_id)
@@ -31,7 +30,6 @@ def lens_blur(img: Image.Image, max_blur_radius: int):
     img = resize_to_512(img)
     original = np.array(img).astype(np.float32)
 
-    # Get depth map
     inputs = processor(images=img, return_tensors="pt")
     with torch.no_grad():
         outputs = depth_model(**inputs)
@@ -49,19 +47,14 @@ def lens_blur(img: Image.Image, max_blur_radius: int):
         .numpy()
     )
 
-    # Normalize and invert depth
     depth_norm = (depth - depth.min()) / (depth.max() - depth.min())
     depth_inverted = 1.0 - depth_norm
 
-    # Dynamically scale blur strength using the slider
-    num_levels = 6  # More levels for smoother transitions
-    max_sigma = (
-        max_blur_radius / 2.0
-    )  # Scale down to reasonable range (e.g. 0–25 → 0–12.5 sigma)
+    num_levels = 6
+    max_sigma = max_blur_radius / 2.0
     blur_levels = np.linspace(0, max_sigma, num_levels)
     blurred_images = [gaussian_filter(original, sigma=(s, s, 0)) for s in blur_levels]
 
-    # Blend based on depth
     blurred_final = np.zeros_like(original, dtype=np.float32)
     depth_scaled = depth_inverted * (num_levels - 1)
     depth_int = np.floor(depth_scaled).astype(int)
@@ -80,56 +73,87 @@ def lens_blur(img: Image.Image, max_blur_radius: int):
     return np.clip(blurred_final, 0, 255).astype(np.uint8)
 
 
-# Separate update functions
+def synthetic_lens_blur(img: Image.Image, max_blur_radius: int):
+    img = resize_to_512(img)
+    original = cv2.cvtColor(np.array(img), cv2.COLOR_RGB2BGR)
+    original_rgb = cv2.cvtColor(original, cv2.COLOR_BGR2RGB)
+
+    depth_norm = np.zeros((original.shape[0], original.shape[1]), dtype=np.float32)
+    cv2.circle(depth_norm, (original.shape[1] // 2, original.shape[0] // 2), 100, 1, -1)
+    depth_norm = cv2.GaussianBlur(depth_norm, (21, 21), 0)
+
+    blurred_image = np.zeros_like(original_rgb)
+
+    for i in range(original.shape[0]):
+        for j in range(original.shape[1]):
+            blur_radius = int(depth_norm[i, j] * max_blur_radius)
+            if blur_radius % 2 == 0:
+                blur_radius += 1
+
+            x_min = max(j - blur_radius, 0)
+            x_max = min(j + blur_radius, original.shape[1])
+            y_min = max(i - blur_radius, 0)
+            y_max = min(i + blur_radius, original.shape[0])
+
+            roi = original_rgb[y_min:y_max, x_min:x_max]
+
+            if blur_radius > 1:
+                blurred_roi = cv2.GaussianBlur(roi, (blur_radius, blur_radius), 0)
+                try:
+                    blurred_image[i, j] = blurred_roi[blur_radius // 2, blur_radius // 2]
+                except:
+                    blurred_image[i, j] = original_rgb[i, j]
+            else:
+                blurred_image[i, j] = original_rgb[i, j]
+
+    return blurred_image
+
+
+def apply_all_blurs(img, g_kernel, lens_radius, synthetic_radius):
+    g = gaussian_blur(img, g_kernel)
+    l = lens_blur(img, lens_radius)
+    s = synthetic_lens_blur(img, synthetic_radius)
+    return g, l, s
+
+
 def update_gaussian(img, kernel_size):
     return gaussian_blur(img, kernel_size)
 
 
-def update_lens(img, max_blur_radius):
-    return lens_blur(img, max_blur_radius)
+def update_lens(img, radius):
+    return lens_blur(img, radius)
 
 
-def apply_blurs(img, kernel_size, max_blur_radius):
-    g_blurred = gaussian_blur(img, kernel_size)
-    l_blurred = lens_blur(img, max_blur_radius)
-    return g_blurred, l_blurred
+def update_synthetic(img, radius):
+    return synthetic_lens_blur(img, radius)
 
 
 with gr.Blocks() as demo:
-    gr.Markdown("## 🌀 Apply Gaussian and Depth-Based Lens Blur")
+    gr.Markdown("## 🌀 Blur Effects Comparison: Gaussian, Depth-Based, Synthetic")
 
     with gr.Row():
         image_input = gr.Image(type="pil", label="Upload Image")
 
     with gr.Row():
-        kernel_slider = gr.Slider(1, 49, step=2, value=11, label="Gaussian Kernel Size")
-        lens_slider = gr.Slider(
-            1, 50, step=1, value=15, label="Max Lens Blur Intensity"
-        )
+        g_slider = gr.Slider(1, 49, step=2, value=11, label="Gaussian Kernel Size")
+        lens_slider = gr.Slider(1, 50, step=1, value=15, label="Depth-Based Blur Intensity")
+        synth_slider = gr.Slider(1, 50, step=1, value=25, label="Synthetic Blur Radius")
 
     with gr.Row():
-        gaussian_output = gr.Image(label="Gaussian Blurred Image")
-        lens_output = gr.Image(label="Depth-Based Lens Blurred Image")
+        g_output = gr.Image(label="Gaussian Blurred Image")
+        l_output = gr.Image(label="Depth-Based Lens Blurred Image")
+        s_output = gr.Image(label="Synthetic Depth Lens Blurred Image")
 
-    # Trigger both when image changes
+    # Initial image upload updates all three
     image_input.change(
-        fn=apply_blurs,
-        inputs=[image_input, kernel_slider, lens_slider],
-        outputs=[gaussian_output, lens_output],
-    )
-
-    # Trigger only gaussian blur
-    kernel_slider.change(
-        fn=update_gaussian,
-        inputs=[image_input, kernel_slider],
-        outputs=gaussian_output,
+        fn=apply_all_blurs,
+        inputs=[image_input, g_slider, lens_slider, synth_slider],
+        outputs=[g_output, l_output, s_output],
     )
 
-    # Trigger only lens blur
-    lens_slider.change(
-        fn=update_lens,
-        inputs=[image_input, lens_slider],
-        outputs=lens_output,
-    )
+    # Individual updates for each slider
+    g_slider.change(fn=update_gaussian, inputs=[image_input, g_slider], outputs=g_output)
+    lens_slider.change(fn=update_lens, inputs=[image_input, lens_slider], outputs=l_output)
+    synth_slider.change(fn=update_synthetic, inputs=[image_input, synth_slider], outputs=s_output)
 
 demo.launch()