Update app.py

app.py

@@ -1,12 +1,44 @@
+from transformers import pipeline
+from PIL import Image, ImageFilter
 import gradio as gr
 import torch
-from PIL import Image, ImageFilter
+import numpy as np
+depth_pipe = pipeline(task="depth-estimation", model="depth-anything/Depth-Anything-V2-Small-hf")
 
-def load_segmentation_model():
+def compute_depth_map_pipeline(image: Image.Image, scale_factor: float) -> np.ndarray:
     """
-    Loads and caches the segmentation model from BEN2.
-    Ensure you have ben2 installed and accessible in your path.
+    Computes a depth map using the HF pipeline.
+    The returned depth is inverted (so near=0 and far=1) and scaled.
     """
+    result = depth_pipe(image)[0]
+    depth_map = np.array(result["depth"])
+    depth_map = 1.0 - depth_map
+    depth_map *= scale_factor
+    return depth_map
+
+def layered_blur(image: Image.Image, depth_map: np.ndarray, num_layers: int, max_blur: float) -> Image.Image:
+    blur_radii = np.linspace(0, max_blur, num_layers)
+    blur_versions = [image.filter(ImageFilter.GaussianBlur(r)) for r in blur_radii]
+    upper_bound = depth_map.max()
+    thresholds = np.linspace(0, upper_bound, num_layers + 1)
+    final_image = blur_versions[-1]
+    for i in range(num_layers - 1, -1, -1):
+        mask_array = np.logical_and(depth_map >= thresholds[i],
+                                    depth_map < thresholds[i + 1]).astype(np.uint8) * 255
+        mask_image = Image.fromarray(mask_array, mode="L")
+        final_image = Image.composite(blur_versions[i], final_image, mask_image)
+    return final_image
+
+def process_depth_blur_pipeline(uploaded_image, max_blur_value, scale_factor, num_layers):
+    if not isinstance(uploaded_image, Image.Image):
+        uploaded_image = Image.open(uploaded_image)
+    image = uploaded_image.convert("RGB").resize((512, 512))
+    depth_map = compute_depth_map_pipeline(image, scale_factor)
+    final_image = layered_blur(image, depth_map, int(num_layers), max_blur_value)
+    return final_image
+
+# --- Segmentation-Based Blur using BEN2 ---
+def load_segmentation_model():
     global seg_model, seg_device
     if "seg_model" not in globals():
         from ben2 import BEN_Base  # Import BEN2
@@ -16,11 +48,7 @@ def load_segmentation_model():
     return seg_model, seg_device
 
 def process_segmentation_blur(uploaded_image, seg_blur_radius: float):
-    """
-    Processes the image with segmentation-based blur.
-    The image is resized to 512x512. A Gaussian blur with the specified radius is applied,
-    then the segmentation mask is computed to composite the sharp foreground over the blurred background.
-    """
+
     if not isinstance(uploaded_image, Image.Image):
         uploaded_image = Image.open(uploaded_image)
     image = uploaded_image.convert("RGB").resize((512, 512))
@@ -35,13 +63,26 @@ def process_segmentation_blur(uploaded_image, seg_blur_radius: float):
     final_image = Image.composite(image, blurred_image, binary_mask)
     return final_image
 
+# --- Merged Gradio Interface ---
 with gr.Blocks() as demo:
-    gr.Markdown("# Gaussian Blur using Image Segmentation BEN2 Model.")
-    seg_img = gr.Image(type="pil", label="Upload Image")
-    seg_blur = gr.Slider(5, 30, value=15, step=1, label="Gaussian Blur Radius")
-    seg_out = gr.Image(label="Gaussian-Based Blurred Image")
-    seg_button = gr.Button("Process Gaussian Blur")
-    seg_button.click(process_segmentation_blur, inputs=[seg_img, seg_blur], outputs=seg_out)
+    gr.Markdown("# Lens Blur & Gaussian Blur")
+    with gr.Tabs():
+        with gr.Tab("Lens Blur"):
+            depth_img = gr.Image(type="pil", label="Upload Image")
+            depth_max_blur = gr.Slider(1.0, 5.0, value=3.0, step=0.1, label="Maximum Blur Radius")
+            depth_scale = gr.Slider(0.1, 1.0, value=0.5, step=0.1, label="Depth Scale Factor")
+            depth_layers = gr.Slider(2, 20, value=8, step=1, label="Number of Layers")
+            depth_out = gr.Image(label="Lens Blurred Image")
+            depth_button = gr.Button("Process Lens Blur")
+            depth_button.click(process_depth_blur_pipeline, 
+                               inputs=[depth_img, depth_max_blur, depth_scale, depth_layers],
+                               outputs=depth_out)
+        with gr.Tab("Guassian Blur"):
+            seg_img = gr.Image(type="pil", label="Upload Image")
+            seg_blur = gr.Slider(5, 30, value=15, step=1, label="Segmentation Blur Radius")
+            seg_out = gr.Image(label="Gaussian Blurred Image")
+            seg_button = gr.Button("Gaussian Blur")
+            seg_button.click(process_segmentation_blur, inputs=[seg_img, seg_blur], outputs=seg_out)
 
 if __name__ == "__main__":
     demo.launch()