Update app.py

app.py

@@ -3,7 +3,6 @@ from transformers import pipeline
 from PIL import Image, ImageFilter
 import numpy as np
 
-# Initialize models with fixed choices
 segmentation_model = pipeline("image-segmentation", model="nvidia/segformer-b1-finetuned-cityscapes-1024-1024")
 depth_estimator = pipeline("depth-estimation", model="Intel/zoedepth-nyu-kitti")
 
@@ -25,47 +24,34 @@ def process_image(input_image, method, blur_intensity):
        - output_image: final composited image.
        - mask_image: the mask used (binary for segmentation, normalized depth for depth-based).
     """
-    # Ensure image is in RGB mode
     input_image = input_image.convert("RGB")
     
     if method == "Segmentation Blur Model":
-        # Use segmentation to obtain a foreground mask
         results = segmentation_model(input_image)
-        # Assume the last result is the main foreground object
         foreground_mask = results[-1]["mask"]
-        # Ensure the mask is grayscale
         foreground_mask = foreground_mask.convert("L")
-        # Threshold to create a binary mask
         binary_mask = foreground_mask.point(lambda p: 255 if p > 128 else 0)
         
-        # Blur the background using Gaussian blur
         blurred_background = input_image.filter(ImageFilter.GaussianBlur(radius=blur_intensity))
         
-        # Composite the final image: keep foreground and use blurred background elsewhere
         output_image = Image.composite(input_image, blurred_background, binary_mask)
         mask_image = binary_mask
         
     elif method == "Monocular Depth Estimation Model":
-        # Generate depth map
         depth_results = depth_estimator(input_image)
         depth_map = depth_results["depth"]
         
-        # Convert depth map to numpy array and normalize to [0, 255]
         depth_array = np.array(depth_map).astype(np.float32)
         norm = (depth_array - depth_array.min()) / (depth_array.max() - depth_array.min() + 1e-8)
         normalized_depth = (norm * 255).astype(np.uint8)
         mask_image = Image.fromarray(normalized_depth)
         
-        # Create fully blurred version using Gaussian blur
         blurred_image = input_image.filter(ImageFilter.GaussianBlur(radius=blur_intensity))
         
-        # Convert images to arrays for blending
         orig_np = np.array(input_image).astype(np.float32)
         blur_np = np.array(blurred_image).astype(np.float32)
-        # Reshape mask for broadcasting
         alpha = normalized_depth[..., np.newaxis] / 255.0
         
-        # Blend pixels: 0 = original; 1 = fully blurred
         blended_np = (1 - alpha) * orig_np + alpha * blur_np
         blended_np = np.clip(blended_np, 0, 255).astype(np.uint8)
         output_image = Image.fromarray(blended_np)
@@ -76,7 +62,6 @@ def process_image(input_image, method, blur_intensity):
     
     return output_image, mask_image
 
-# Build a Gradio interface
 with gr.Blocks() as demo:
     gr.Markdown("## FocusFusion: Segmentation & Depth Blur")
     
@@ -93,12 +78,10 @@ with gr.Blocks() as demo:
             output_image = gr.Image(label="Output Image")
             mask_output = gr.Image(label="Mask")
     
-    # Set up event handler
     run_button.click(
         fn=process_image, 
         inputs=[input_image, method, blur_intensity], 
         outputs=[output_image, mask_output]
     )
 
-# Launch the app
 demo.launch()