Added app.py and requirements.txt

app.py

@@ -0,0 +1,205 @@
+import gradio as gr
+import torch
+import cv2 as cv
+import numpy as np
+import transformers as t
+from PIL import Image
+import warnings
+warnings.filterwarnings('ignore')
+
+# Load models globally to avoid reloading
+print("Loading models...")
+# MaskFormer for person segmentation
+feature_extractor = t.MaskFormerFeatureExtractor.from_pretrained("facebook/maskformer-swin-base-coco")
+maskformer_model = t.MaskFormerForInstanceSegmentation.from_pretrained("facebook/maskformer-swin-base-coco")
+
+# DPT for depth estimation
+image_processor = t.DPTImageProcessor.from_pretrained("Intel/dpt-hybrid-midas")
+depth_model = t.DPTForDepthEstimation.from_pretrained("Intel/dpt-hybrid-midas", low_cpu_mem_usage=True)
+print("Models loaded successfully!")
+
+def apply_gaussian_blur(image, kernel_size=15, sigma=10):
+    """Apply simple Gaussian blur to entire image"""
+    image_np = np.array(image)
+    d1_kernel = cv.getGaussianKernel(ksize=kernel_size, sigma=sigma, ktype=cv.CV_32F)
+    d2_kernel = d1_kernel @ d1_kernel.T
+    blurred = cv.filter2D(image_np, kernel=d2_kernel, ddepth=-1)
+    return Image.fromarray(blurred)
+
+def apply_portrait_blur(image, kernel_size=15, sigma=10):
+    """Apply blur to background only, keeping person in focus"""
+    # Convert to RGB if needed
+    if image.mode != 'RGB':
+        image = image.convert('RGB')
+    
+    # Get person segmentation mask
+    inputs = feature_extractor(images=image, return_tensors="pt")
+    with torch.no_grad():
+        outputs = maskformer_model(**inputs)
+    
+    segment_result = feature_extractor.post_process_panoptic_segmentation(
+        outputs, target_sizes=[image.size[::-1]]
+    )[0]
+    
+    predicted_panoptic_map = segment_result["segmentation"]
+    # Class 5 is 'person' in COCO dataset
+    person_mask = predicted_panoptic_map == 5
+    person_mask = person_mask.cpu().numpy()
+    # Invert: 0 for person, 255 for background
+    person_mask = np.where(person_mask, 0, 1) * 255
+    person_mask = np.array(person_mask, dtype='uint8')
+    
+    # Apply Gaussian blur
+    image_np = np.array(image, dtype='uint8')
+    d1_kernel = cv.getGaussianKernel(ksize=kernel_size, sigma=sigma, ktype=cv.CV_32F)
+    d2_kernel = d1_kernel @ d1_kernel.T
+    full_image_blur = cv.filter2D(image_np, kernel=d2_kernel, ddepth=-1)
+    
+    # Extract background from blurred image
+    segment_background = cv.bitwise_and(full_image_blur, full_image_blur, mask=person_mask)
+    
+    # Extract person from original image
+    inverted_person_mask = cv.bitwise_not(person_mask)
+    segment_person = cv.bitwise_and(image_np, image_np, mask=inverted_person_mask)
+    
+    # Combine
+    result = cv.add(segment_background, segment_person)
+    return Image.fromarray(result)
+
+def apply_lens_blur(image, blur_threshold=10):
+    """Apply depth-based lens blur effect"""
+    # Convert to RGB if needed
+    if image.mode != 'RGB':
+        image = image.convert('RGB')
+    
+    # Get depth map
+    inputs = image_processor(images=image, return_tensors="pt")
+    with torch.no_grad():
+        outputs = depth_model(**inputs)
+        predicted_depth = outputs.predicted_depth
+    
+    # Interpolate to original size
+    prediction = torch.nn.functional.interpolate(
+        predicted_depth.unsqueeze(1),
+        size=image.size[::-1],
+        mode="bicubic",
+        align_corners=False
+    )
+    
+    # Convert to depth map
+    output = prediction.squeeze().cpu().numpy()
+    formatted = (output * 255 / np.max(output)).astype("uint8")
+    depth_map = np.array(formatted, dtype='uint8')
+    
+    # Normalize depth map to 0-15 range
+    normalized_depth_map = np.array(depth_map / 255 * 15, dtype='uint8')
+    
+    # Apply variable blur based on depth
+    image_np = np.array(image, dtype='uint8')
+    result = np.zeros_like(image_np, dtype='uint8')
+    
+    for i in range(15, -1, -1):
+        if i < blur_threshold:
+            radius = 15 - i
+            if radius > 0:
+                d1_kernel = cv.getGaussianKernel(ksize=radius, sigma=10, ktype=cv.CV_32F)
+                d2_kernel = d1_kernel @ d1_kernel.T
+                full_image_blur = cv.filter2D(image_np, ddepth=-1, kernel=d2_kernel)
+            else:
+                full_image_blur = image_np
+        else:
+            full_image_blur = image_np
+        
+        mask = np.where(normalized_depth_map == i, 255, 0)
+        mask = np.array(mask, dtype='uint8')
+        segment_background = cv.bitwise_and(full_image_blur, full_image_blur, mask=mask)
+        result = cv.bitwise_or(result, segment_background)
+    
+    return Image.fromarray(result)
+
+def process_image(image, effect_type, kernel_size, sigma, blur_threshold):
+    """Main processing function"""
+    if image is None:
+        return None
+    
+    if effect_type == "Gaussian Blur":
+        return apply_gaussian_blur(image, kernel_size, sigma)
+    elif effect_type == "Portrait Blur (Background Only)":
+        return apply_portrait_blur(image, kernel_size, sigma)
+    elif effect_type == "Lens Blur (Depth-based)":
+        return apply_lens_blur(image, blur_threshold)
+    
+    return image
+
+# Create Gradio interface
+with gr.Blocks(title="Image Blur Effects") as demo:
+    gr.Markdown(
+        """
+        # 📸 Image Blur Effects
+        Upload an image and apply different blur effects:
+        - **Gaussian Blur**: Simple blur applied to entire image
+        - **Portrait Blur**: Smart background blur keeping people in focus
+        - **Lens Blur**: Depth-based blur simulating camera lens effects
+        """
+    )
+    
+    with gr.Row():
+        with gr.Column():
+            input_image = gr.Image(type="pil", label="Upload Image")
+            effect_type = gr.Radio(
+                choices=[
+                    "Gaussian Blur",
+                    "Portrait Blur (Background Only)",
+                    "Lens Blur (Depth-based)"
+                ],
+                value="Gaussian Blur",
+                label="Select Effect"
+            )
+            
+            with gr.Accordion("Advanced Settings", open=False):
+                kernel_size = gr.Slider(
+                    minimum=3, maximum=31, step=2, value=15,
+                    label="Kernel Size (for Gaussian/Portrait Blur)"
+                )
+                sigma = gr.Slider(
+                    minimum=1, maximum=20, value=10,
+                    label="Sigma (for Gaussian/Portrait Blur)"
+                )
+                blur_threshold = gr.Slider(
+                    minimum=0, maximum=15, value=10,
+                    label="Blur Threshold (for Lens Blur - higher = more in focus)"
+                )
+            
+            process_btn = gr.Button("Apply Effect", variant="primary")
+        
+        with gr.Column():
+            output_image = gr.Image(type="pil", label="Result")
+    
+    gr.Markdown(
+        """
+        ### Tips:
+        - **Gaussian Blur**: Adjust kernel size and sigma for blur intensity
+        - **Portrait Blur**: Works best with clear person in image
+        - **Lens Blur**: Mimics DSLR depth-of-field effect
+        """
+    )
+    
+    process_btn.click(
+        fn=process_image,
+        inputs=[input_image, effect_type, kernel_size, sigma, blur_threshold],
+        outputs=output_image
+    )
+    
+    # Example images
+    gr.Examples(
+        examples=[
+            ["example.jpg", "Gaussian Blur", 15, 10, 10],
+        ],
+        inputs=[input_image, effect_type, kernel_size, sigma, blur_threshold],
+        outputs=output_image,
+        fn=process_image,
+        cache_examples=False,
+    )
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,7 @@
+gradio==4.44.0
+torch==2.1.0
+transformers==4.35.0
+opencv-python-headless==4.8.1.78
+numpy==1.24.3
+Pillow==10.1.0
+timm==0.9.12