Create app.py

app.py

@@ -0,0 +1,255 @@
+"""
+Face Privacy Tool (Gradio UI with YOLOv8 Segmentation & Video Support)
+"""
+
+# --- Standard Libraries ---
+import logging
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Tuple
+import tempfile
+import os
+
+# --- Computer Vision & UI Libraries ---
+import cv2
+import numpy as np
+import gradio as gr
+from ultralytics import YOLO
+
+# --- Configure Logging ---
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+logger = logging.getLogger(__name__)
+
+# ====================================================
+# CONFIGURATION DATA CLASSES
+# ====================================================
+@dataclass
+class BlurConfig:
+    type: str = "gaussian"
+    intensity: float = 1.5
+    pixel_size: int = 30
+    solid_color: Tuple[int, int, int] = (0, 0, 0)
+    adaptive_blur: bool = True
+    min_kernel: int = 15
+    max_kernel: int = 95
+
+@dataclass
+class DetectionConfig:
+    min_confidence: float = 0.4
+    model_path: str = "yolov8n-seg.pt"  # YOLOv8 segmentation model
+
+@dataclass
+class AppConfig:
+    blur: BlurConfig = field(default_factory=BlurConfig)
+    detection: DetectionConfig = field(default_factory=DetectionConfig)
+    scaling_factor: float = 1.2
+    forehead_margin: int = 20
+    face_margin: int = 15
+
+# ====================================================
+# BLUR EFFECTS
+# ====================================================
+class BlurEffect(ABC):
+    def __init__(self, config: BlurConfig):
+        self.config = config
+
+    @abstractmethod
+    def apply(self, image: np.ndarray, roi: Tuple[int, int, int, int]) -> np.ndarray:
+        pass
+
+class GaussianBlur(BlurEffect):
+    def apply(self, image: np.ndarray, roi: Tuple[int, int, int, int]) -> np.ndarray:
+        x, y, w, h = roi
+        face_roi = image[y:y+h, x:x+w]
+        if face_roi.size == 0:
+            return image
+        if self.config.adaptive_blur:
+            min_dim = min(w, h)
+            kernel_val = int(min_dim * 0.25 * self.config.intensity)
+            kernel_val = max(self.config.min_kernel, min(kernel_val, self.config.max_kernel))
+        else:
+            kernel_val = 45
+        kernel_val = kernel_val | 1
+        blurred_roi = cv2.GaussianBlur(face_roi, (kernel_val, kernel_val), 0)
+        image[y:y+h, x:x+w] = blurred_roi
+        return image
+
+class PixelateBlur(BlurEffect):
+    def apply(self, image: np.ndarray, roi: Tuple[int, int, int, int]) -> np.ndarray:
+        x, y, w, h = roi
+        face_roi = image[y:y+h, x:x+w]
+        if face_roi.size == 0:
+            return image
+        h_roi, w_roi, _ = face_roi.shape
+        pixel_size = self.config.pixel_size
+        if pixel_size <= 0:
+            return image
+        small = cv2.resize(face_roi, (max(1, w_roi // pixel_size), max(1, h_roi // pixel_size)), interpolation=cv2.INTER_LINEAR)
+        pixelated = cv2.resize(small, (w_roi, h_roi), interpolation=cv2.INTER_NEAREST)
+        image[y:y+h, x:x+w] = pixelated
+        return image
+
+class SolidColorBlur(BlurEffect):
+    def apply(self, image: np.ndarray, roi: Tuple[int, int, int, int]) -> np.ndarray:
+        x, y, w, h = roi
+        cv2.rectangle(image, (x, y), (x+w, y+h), self.config.solid_color, -1)
+        return image
+
+def get_blur_effect(config: BlurConfig) -> BlurEffect:
+    if config.type == "gaussian":
+        return GaussianBlur(config)
+    if config.type == "pixelate":
+        return PixelateBlur(config)
+    if config.type == "solid":
+        return SolidColorBlur(config)
+    raise ValueError(f"Unknown blur type: {config.type}")
+
+# ====================================================
+# YOLOv8 DETECTOR
+# ====================================================
+class YOLOv8Detector:
+    def __init__(self, config: DetectionConfig):
+        self.model = YOLO(config.model_path)
+        self.min_conf = config.min_confidence
+
+    def detect_faces(self, image: np.ndarray) -> List[Dict[str, Any]]:
+        """Detect faces/objects with YOLOv8 segmentation"""
+        results = self.model(image, conf=self.min_conf)
+        faces = []
+        for r in results:
+            for box in r.boxes:
+                x1, y1, x2, y2 = map(int, box.xyxy[0].tolist())
+                faces.append({"x": x1, "y": y1, "width": x2 - x1, "height": y2 - y1})
+        return faces
+
+# ====================================================
+# MAIN APPLICATION
+# ====================================================
+class FacePrivacyApp:
+    def __init__(self, config: AppConfig):
+        self.config = config
+        self.blur_effect = get_blur_effect(config.blur)
+        self.detector = YOLOv8Detector(config.detection)
+
+    def _expand_bbox(self, bbox: Dict[str, Any], img_shape: Tuple[int, int]) -> Tuple[int, int, int, int]:
+        h_img, w_img = img_shape
+        new_w = int(bbox["width"] * self.config.scaling_factor)
+        new_h = int(bbox["height"] * self.config.scaling_factor)
+        x_offset = (new_w - bbox["width"]) // 2
+        y_offset = (new_h - bbox["height"]) // 2
+        x = max(0, bbox["x"] - x_offset - self.config.face_margin)
+        y = max(0, bbox["y"] - y_offset - self.config.forehead_margin)
+        w = min(w_img - x, new_w + 2 * self.config.face_margin)
+        h = min(h_img - y, new_h + self.config.forehead_margin)
+        return x, y, w, h
+
+    def process_image(self, image: np.ndarray) -> np.ndarray:
+        writable_image = image.copy()
+        faces = self.detector.detect_faces(writable_image)
+        for face in faces:
+            expanded_roi = self._expand_bbox(face, writable_image.shape[:2])
+            writable_image = self.blur_effect.apply(writable_image, expanded_roi)
+        return writable_image
+
+# ====================================================
+# VIDEO PROCESSING FUNCTION
+# ====================================================
+def process_video_fn(video_file, blur_type, blur_amount, blur_size):
+    if video_file is None:
+        return None
+
+    app_config = AppConfig(
+        scaling_factor=blur_size,
+        blur=BlurConfig(type=blur_type, intensity=blur_amount, pixel_size=int(blur_amount))
+    )
+    app = FacePrivacyApp(app_config)
+
+    cap = cv2.VideoCapture(video_file.name)
+    if not cap.isOpened():
+        logger.warning(f"Cannot open video: {video_file.name}")
+        return None
+
+    out_fd, out_path = tempfile.mkstemp(suffix=".mp4")
+    os.close(out_fd)
+
+    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+    fps = cap.get(cv2.CAP_PROP_FPS)
+    width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    out_vid = cv2.VideoWriter(out_path, fourcc, fps, (width, height))
+
+    while True:
+        ret, frame = cap.read()
+        if not ret:
+            break
+        processed_frame = app.process_image(frame)
+        out_vid.write(processed_frame)
+
+    cap.release()
+    out_vid.release()
+    return out_path
+
+# ====================================================
+# GRADIO INTERFACE FUNCTIONS
+# ====================================================
+def process_single_image_fn(media, blur_type, blur_amount, blur_size):
+    if media is None:
+        return None
+    app_config = AppConfig(
+        scaling_factor=blur_size,
+        blur=BlurConfig(type=blur_type, intensity=blur_amount, pixel_size=int(blur_amount))
+    )
+    app = FacePrivacyApp(app_config)
+    return app.process_image(media)
+
+def update_amount_slider_visibility(blur_type):
+    return gr.update(visible=(blur_type != "solid"))
+
+# ====================================================
+# BUILD GRADIO APP
+# ====================================================
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# Face Privacy Tool (YOLOv8 Segmentation & Video)")
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("### ⚙️ Settings")
+            blur_type = gr.Radio(["gaussian", "pixelate", "solid"], value="pixelate", label="Blur Type")
+            blur_amount = gr.Slider(1, 50, step=1, value=25, label="Blur Amount")
+            blur_size = gr.Slider(1.0, 2.0, step=0.05, value=1.2, label="Blur Size (Expansion)")
+
+        with gr.Column(scale=2):
+            with gr.Tabs():
+                with gr.TabItem("Single Image"):
+                    image_input = gr.Image(sources=["upload"], type="numpy", label="Upload Image")
+                    image_output = gr.Image(type="numpy", label="Blurred Image")
+                    single_image_button = gr.Button("Apply Blur to Single Image", variant="primary")
+                    single_image_button.click(
+                        fn=process_single_image_fn,
+                        inputs=[image_input, blur_type, blur_amount, blur_size],
+                        outputs=image_output
+                    )
+
+                with gr.TabItem("Video Upload"):
+                    video_input = gr.File(file_types=[".mp4", ".mov", ".avi"], label="Upload Video")
+                    video_output = gr.Video(label="Processed Video")
+                    process_video_button = gr.Button("Process Video", variant="primary")
+                    process_video_button.click(
+                        fn=process_video_fn,
+                        inputs=[video_input, blur_type, blur_amount, blur_size],
+                        outputs=video_output
+                    )
+
+                with gr.TabItem("Webcam"):
+                    webcam_input = gr.Image(sources=["webcam"], type="numpy", streaming=True, label="Live Webcam")
+                    webcam_output = gr.Image(type="numpy", label="Processed Feed")
+                    webcam_input.stream(
+                        fn=process_single_image_fn,
+                        inputs=[webcam_input, blur_type, blur_amount, blur_size],
+                        outputs=webcam_output
+                    )
+
+    blur_type.change(fn=update_amount_slider_visibility, inputs=blur_type, outputs=blur_amount)
+
+if __name__ == "__main__":
+    demo.launch()