Modify lens blur

app.py

@@ -2,12 +2,16 @@ import cv2
 import numpy as np
 import gradio as gr
 from PIL import Image
+from scipy.ndimage import gaussian_filter
+from transformers import (
+    AutoImageProcessor,
+    AutoModelForDepthEstimation,
+)
+import torch
 
 
 def resize_to_512(img: Image.Image) -> Image.Image:
-    if img.size != (512, 512):
-        return img.resize((512, 512))
-    return img
+    return img.resize((512, 512)) if img.size != (512, 512) else img
 
 
 def gaussian_blur(img: Image.Image, kernel_size: int):
@@ -17,65 +21,115 @@ 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)
+
+
 def 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)
+    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)
+        predicted_depth = outputs.predicted_depth
+
+    depth = (
+        torch.nn.functional.interpolate(
+            predicted_depth.unsqueeze(1),
+            size=(512, 512),
+            mode="bicubic",
+            align_corners=False,
+        )
+        .squeeze()
+        .cpu()
+        .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)
+    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)
+    depth_frac = depth_scaled - depth_int
+
+    for i in range(num_levels - 1):
+        mask = depth_int == i
+        alpha = depth_frac[mask]
+        for c in range(3):
+            blended = (
+                blurred_images[i][..., c][mask] * (1 - alpha)
+                + blurred_images[i + 1][..., c][mask] * alpha
+            )
+            blurred_final[..., c][mask] = blended
 
-    # Create synthetic depth map
-    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)
+    return np.clip(blurred_final, 0, 255).astype(np.uint8)
 
-    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
+# Separate update functions
+def update_gaussian(img, kernel_size):
+    return gaussian_blur(img, kernel_size)
 
-            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]
+def update_lens(img, max_blur_radius):
+    return lens_blur(img, max_blur_radius)
 
-            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_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
 
 
 with gr.Blocks() as demo:
-    gr.Markdown("## Gaussian and Lens Blur App")
+    gr.Markdown("## 🌀 Apply Gaussian and Depth-Based Lens Blur")
+
     with gr.Row():
-        image_input = gr.Image(type="pil", label="Upload an Image")
+        image_input = gr.Image(type="pil", label="Upload Image")
+
     with gr.Row():
-        kernel_slider = gr.Slider(1, 49, value=11, step=2, label="Gaussian Kernel Size")
-        max_blur_slider = gr.Slider(
-            1, 50, value=15, step=1, label="Max Lens Blur Radius"
+        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"
         )
+
     with gr.Row():
         gaussian_output = gr.Image(label="Gaussian Blurred Image")
         lens_output = gr.Image(label="Depth-Based Lens Blurred Image")
-    with gr.Row():
-        blur_btn = gr.Button("Apply Blur")
 
-    blur_btn.click(
-        fn=gaussian_blur, inputs=[image_input, kernel_slider], outputs=gaussian_output
+    # Trigger both when image changes
+    image_input.change(
+        fn=apply_blurs,
+        inputs=[image_input, kernel_slider, lens_slider],
+        outputs=[gaussian_output, lens_output],
     )
-    blur_btn.click(
-        fn=lens_blur, inputs=[image_input, max_blur_slider], outputs=lens_output
+
+    # Trigger only gaussian blur
+    kernel_slider.change(
+        fn=update_gaussian,
+        inputs=[image_input, kernel_slider],
+        outputs=gaussian_output,
+    )
+
+    # Trigger only lens blur
+    lens_slider.change(
+        fn=update_lens,
+        inputs=[image_input, lens_slider],
+        outputs=lens_output,
     )
 
 demo.launch()

requirements.txt

@@ -2,3 +2,4 @@ gradio
 opencv-python
 numpy
 pillow
+transformers