Spaces:
Sleeping
Sleeping
| import gradio as gr | |
| import numpy as np | |
| from transformers import BeitImageProcessor, BeitForSemanticSegmentation, DPTImageProcessor, DPTForDepthEstimation | |
| from PIL import Image, ImageFilter | |
| import torch | |
| import cv2 | |
| # Load the updated BeitImageProcessor for segmentation | |
| segmentation_processor = BeitImageProcessor.from_pretrained("microsoft/beit-base-finetuned-ade-640-640") | |
| segmentation_model = BeitForSemanticSegmentation.from_pretrained("microsoft/beit-base-finetuned-ade-640-640") | |
| # Load the updated DPTImageProcessor for depth estimation | |
| depth_feature_extractor = DPTImageProcessor.from_pretrained("Intel/dpt-large") | |
| depth_model = DPTForDepthEstimation.from_pretrained("Intel/dpt-large") | |
| def apply_gaussian_blur(image): | |
| # Resize and preprocess the image | |
| image = image.resize((512, 512)).convert("RGB") | |
| inputs = segmentation_processor(image, return_tensors="pt") | |
| # Perform semantic segmentation using the model | |
| with torch.no_grad(): | |
| outputs = segmentation_model(**inputs) | |
| logits = outputs.logits | |
| # Get the predicted class for each pixel | |
| segmentation = torch.argmax(logits, dim=1)[0] # Shape: [height, width] | |
| # Create a binary mask for the 'person' class | |
| person_index = 12 # Assuming 12 is the 'person' class index | |
| binary_mask = (segmentation == person_index).numpy().astype(np.uint8) * 255 # Convert to 0 and 255 | |
| # Resize the mask to match the image size (512x512) | |
| binary_mask = cv2.resize(binary_mask, (512, 512), interpolation=cv2.INTER_NEAREST) | |
| # Convert the original image to a numpy array | |
| image_np = np.array(image) | |
| # Apply Gaussian blur to the entire image | |
| blurred_image = cv2.GaussianBlur(image_np, (0, 0), sigmaX=15, sigmaY=15) | |
| # Normalize the mask to range between 0 and 1 | |
| normalized_mask = binary_mask / 255.0 | |
| normalized_mask = np.expand_dims(normalized_mask, axis=-1) # Add channel dimension | |
| # Create the composite image with the blurred background | |
| final_image = (image_np * normalized_mask + blurred_image * (1 - normalized_mask)).astype(np.uint8) | |
| # Convert back to PIL Image | |
| final_image_pil = Image.fromarray(final_image) | |
| return final_image_pil | |
| def apply_lens_blur(image): | |
| # Resize and preprocess the image | |
| image = image.resize((512, 512)).convert("RGB") | |
| depth_inputs = depth_feature_extractor(images=image, return_tensors="pt") | |
| # Perform depth estimation | |
| with torch.no_grad(): | |
| depth_outputs = depth_model(**depth_inputs) | |
| predicted_depth = depth_outputs.predicted_depth[0].cpu().numpy() | |
| # Normalize and invert the depth map | |
| min_depth = predicted_depth.min() | |
| max_depth = predicted_depth.max() | |
| normalized_depth = (predicted_depth - min_depth) / (max_depth - min_depth) | |
| inverted_depth = 1 - normalized_depth | |
| # Resize the depth map to match the original image size | |
| depth_weight_resized = Image.fromarray((inverted_depth * 255).astype(np.uint8)).resize((512, 512)) | |
| depth_weight_resized = np.array(depth_weight_resized) / 255.0 | |
| depth_weight_resized = depth_weight_resized[:, :, np.newaxis] | |
| # Apply maximum Gaussian blur to the original image | |
| blurred_image = image.filter(ImageFilter.GaussianBlur(radius=15)) | |
| # Convert images to numpy arrays | |
| original_np = np.array(image).astype(np.float32) | |
| blurred_np = np.array(blurred_image).astype(np.float32) | |
| # Blend the images based on the resized depth map | |
| output_np = (1 - depth_weight_resized) * original_np + depth_weight_resized * blurred_np | |
| # Convert back to uint8 | |
| output_np = np.clip(output_np, 0, 255).astype(np.uint8) | |
| return Image.fromarray(output_np) | |
| # Define a function to call the correct blurring function based on user selection | |
| def apply_blur(effect, image): | |
| if effect == "Gaussian Blur": | |
| return apply_gaussian_blur(image) | |
| elif effect == "Lens Blur": | |
| return apply_lens_blur(image) | |
| # Define the Gradio interface | |
| interface = gr.Interface( | |
| fn=apply_blur, | |
| inputs=[ | |
| gr.Dropdown(choices=["Gaussian Blur", "Lens Blur"], label="Select Blur Effect"), | |
| gr.Image(type="pil") | |
| ], | |
| outputs=gr.Image(type="pil"), | |
| title="Blur Effects with Hugging Face", | |
| description="Apply Gaussian Blur or Lens Blur to images using semantic segmentation or depth estimation." | |
| ) | |
| # Launch the Gradio interface | |
| interface.launch() | |