Upload 2 files

app.py

@@ -0,0 +1,233 @@
+import gradio as gr
+import numpy as np
+import cv2
+from PIL import Image
+import torch
+from transformers import AutoImageProcessor, AutoModelForSemanticSegmentation, AutoModelForDepthEstimation
+
+# Load models
+print("Loading models...")
+seg_processor = AutoImageProcessor.from_pretrained("nvidia/segformer-b0-finetuned-ade-512-512")
+seg_model = AutoModelForSemanticSegmentation.from_pretrained("nvidia/segformer-b0-finetuned-ade-512-512")
+
+depth_processor = AutoImageProcessor.from_pretrained("Intel/dpt-large")
+depth_model = AutoModelForDepthEstimation.from_pretrained("Intel/dpt-large")
+
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+seg_model = seg_model.to(device)
+depth_model = depth_model.to(device)
+print(f"Models loaded on {device}")
+
+def get_person_mask(image):
+    """Get segmentation mask for person"""
+    inputs = seg_processor(images=image, return_tensors="pt").to(device)
+
+    with torch.no_grad():
+        outputs = seg_model(**inputs)
+
+    segmentation = outputs.logits.argmax(dim=1).squeeze().cpu().numpy()
+    person_mask = (segmentation == 12).astype(np.uint8)
+
+    # Clean up mask
+    kernel = np.ones((5, 5), np.uint8)
+    person_mask = cv2.morphologyEx(person_mask, cv2.MORPH_CLOSE, kernel, iterations=3)
+    person_mask = cv2.morphologyEx(person_mask, cv2.MORPH_OPEN, kernel, iterations=2)
+
+    return person_mask
+
+def get_depth_map(image):
+    """Get depth map using DPT"""
+    inputs = depth_processor(images=image, return_tensors="pt").to(device)
+
+    with torch.no_grad():
+        outputs = depth_model(**inputs)
+        predicted_depth = outputs.predicted_depth
+
+    h, w = image.size[1], image.size[0]
+    prediction = torch.nn.functional.interpolate(
+        predicted_depth.unsqueeze(1),
+        size=(h, w),
+        mode="bicubic",
+        align_corners=False,
+    ).squeeze()
+
+    depth_map = prediction.cpu().numpy()
+
+    # Normalize to [0, 1]
+    depth_normalized = (depth_map - depth_map.min()) / (depth_map.max() - depth_map.min())
+
+    # Invert so closer = smaller values
+    depth_normalized = 1 - depth_normalized
+
+    return depth_normalized
+
+def apply_gaussian_blur(image, person_mask, sigma):
+    """Apply Gaussian blur to background only"""
+    img_array = np.array(image)
+    blurred_image = cv2.GaussianBlur(img_array, (0, 0), sigmaX=sigma)
+
+    result = img_array.copy()
+    result[person_mask == 0] = blurred_image[person_mask == 0]
+
+    return Image.fromarray(result)
+
+def apply_variable_blur(image, depth_map, max_sigma, num_layers=20):
+    """Apply variable blur based on depth"""
+    img_array = np.array(image)
+    result = np.zeros_like(img_array, dtype=np.float32)
+    depth_levels = np.linspace(0, 1, num_layers + 1)
+
+    for i in range(num_layers):
+        mask = ((depth_map >= depth_levels[i]) & (depth_map < depth_levels[i+1]))
+
+        if mask.sum() < 1:
+            continue
+
+        avg_depth = (depth_levels[i] + depth_levels[i+1]) / 2
+        sigma = avg_depth * max_sigma
+
+        if sigma > 0.5:
+            blurred = cv2.GaussianBlur(img_array, (0, 0), sigma)
+        else:
+            blurred = img_array
+
+        mask_3ch = np.stack([mask, mask, mask], axis=-1)
+        result += blurred * mask_3ch
+
+    return Image.fromarray(np.clip(result, 0, 255).astype(np.uint8))
+
+def process_image(image, effect_type, sigma_value):
+    """Main processing function"""
+    if image is None:
+        return None, None, None, "Please upload an image"
+
+    # Resize to manageable size
+    image = image.resize((512, 512), Image.LANCZOS)
+
+    if effect_type == "Gaussian Blur":
+        # Get person mask
+        person_mask = get_person_mask(image)
+
+        # Apply Gaussian blur
+        result = apply_gaussian_blur(image, person_mask, sigma_value)
+
+        # Create mask visualization
+        mask_vis = Image.fromarray(person_mask * 255)
+
+        info = f"✅ Gaussian Blur Applied\nSigma: {sigma_value}\nMethod: Uniform background blur"
+
+        return result, mask_vis, None, info
+
+    else:  # Lens Blur
+        # Get depth map
+        depth_map = get_depth_map(image)
+
+        # Apply lens blur
+        result = apply_variable_blur(image, depth_map, max_sigma=sigma_value, num_layers=20)
+
+        # Create depth visualization
+        depth_uint8 = (depth_map * 255).astype(np.uint8)
+        depth_colored = cv2.applyColorMap(depth_uint8, cv2.COLORMAP_TURBO)
+        depth_colored = cv2.cvtColor(depth_colored, cv2.COLOR_BGR2RGB)
+        depth_vis = Image.fromarray(depth_colored)
+
+        info = f"✅ Depth-Based Lens Blur Applied\nMax Sigma: {sigma_value}\nMethod: Variable blur by depth"
+
+        return result, depth_vis, None, info
+
+# Create Gradio interface
+with gr.Blocks(title="Portrait Blur Effects - Vision Transformer Demo", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("""
+    # 🎨 Portrait Blur Effects with Vision Transformers
+    ### EEE 598 Assignment 4 - Problem 3 Interactive Demo
+
+    Upload a portrait image and apply either **Gaussian Blur** (uniform background blur) or **Lens Blur** (depth-based realistic blur).
+
+    **Models Used:**
+    - 🧠 **SegFormer** (nvidia/segformer-b0-finetuned-ade-512-512) for segmentation
+    - 🧠 **DPT** (Intel/dpt-large) for depth estimation
+    """)
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("### 📤 Input")
+            input_image = gr.Image(type="pil", label="Upload Portrait Image")
+
+            effect_type = gr.Radio(
+                choices=["Gaussian Blur", "Lens Blur"],
+                value="Gaussian Blur",
+                label="Effect Type",
+                info="Choose blur method"
+            )
+
+            sigma_slider = gr.Slider(
+                minimum=1,
+                maximum=30,
+                value=15,
+                step=1,
+                label="Blur Strength (Sigma)",
+                info="Higher = more blur"
+            )
+
+            process_btn = gr.Button("🚀 Apply Blur Effect", variant="primary", size="lg")
+
+            info_box = gr.Textbox(label="Status", lines=3, interactive=False)
+
+        with gr.Column(scale=2):
+            gr.Markdown("### 📥 Results")
+
+            with gr.Row():
+                output_image = gr.Image(type="pil", label="Result", interactive=False)
+                aux_image = gr.Image(type="pil", label="Segmentation Mask / Depth Map", interactive=False)
+
+    with gr.Row():
+        gr.Markdown("""
+        ---
+        ### 📖 How It Works
+
+        #### Gaussian Blur (Task 2):
+        1. **SegFormer** segments the image to identify the person
+        2. Gaussian blur (σ=15) is applied uniformly to the background
+        3. Person remains sharp, creating a portrait mode effect
+
+        #### Lens Blur (Task 4):
+        1. **DPT** estimates depth at each pixel
+        2. Blur intensity varies based on distance from camera
+        3. Creates realistic depth-of-field like expensive cameras
+
+        ---
+        **Comparison:**
+        - **Gaussian Blur:** Fast, sharp boundaries, good for video calls (Zoom effect)
+        - **Lens Blur:** Realistic, smooth gradients, good for photography
+
+        ---
+        🎓 **EEE 598 Deep Learning for Engineers** | Arizona State University
+        """)
+
+    # Examples
+    gr.Markdown("### 🎯 Try These Examples")
+    gr.Examples(
+        examples=[
+            [None, "Gaussian Blur", 15],
+            [None, "Lens Blur", 15],
+            [None, "Gaussian Blur", 25],
+            [None, "Lens Blur", 10],
+        ],
+        inputs=[input_image, effect_type, sigma_slider],
+        label="Quick Examples (Upload your own image first)"
+    )
+
+    # Event handler
+    process_btn.click(
+        fn=process_image,
+        inputs=[input_image, effect_type, sigma_slider],
+        outputs=[output_image, aux_image, None, info_box]
+    )
+
+# Launch
+if __name__ == "__main__":
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False
+    )

requirements (1).txt

@@ -0,0 +1,8 @@
+gradio==4.44.0
+transformers==4.44.0
+torch==2.1.0
+torchvision==0.16.0
+opencv-python-headless==4.10.0.84
+pillow==10.4.0
+numpy==1.26.4
+scipy==1.13.1