Update app.py

app.py

@@ -4,11 +4,12 @@ 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 atexit
 import tempfile
 import os
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Tuple, Optional
 
 # --- Computer Vision & UI Libraries ---
 import cv2
@@ -20,14 +21,38 @@ from ultralytics import YOLO
 logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
 logger = logging.getLogger(__name__)
 
+# ====================================================
+# TEMPORARY FILE CLEANUP
+# ====================================================
+TEMP_FILES = []
+
+def cleanup_temp_files():
+    """Clean up any temporary files created during the session on exit."""
+    for f in TEMP_FILES:
+        try:
+            if os.path.exists(f):
+                os.remove(f)
+                logger.info(f"🗑️ Cleaned up temporary file: {f}")
+        except Exception as e:
+            logger.warning(f"⚠️ Failed to delete temporary file {f}: {e}")
+
+atexit.register(cleanup_temp_files)
+
+def create_temp_file(suffix=".mp4") -> str:
+    """Creates a temporary file and registers it for cleanup."""
+    path = tempfile.mktemp(suffix=suffix)
+    TEMP_FILES.append(path)
+    return path
+
 # ====================================================
 # CONFIGURATION DATA CLASSES
 # ====================================================
 @dataclass
 class BlurConfig:
-    type: str = "gaussian"
-    intensity: float = 1.5
-    pixel_size: int = 30
+    """Configuration for blur effects."""
+    type: str = "pixelate"
+    intensity: float = 25.0
+    pixel_size: int = 25
     solid_color: Tuple[int, int, int] = (0, 0, 0)
     adaptive_blur: bool = True
     min_kernel: int = 15
@@ -35,11 +60,13 @@ class BlurConfig:
 
 @dataclass
 class DetectionConfig:
-    min_confidence: float = 0.4
-    model_path: str = "yolov8n-seg.pt"  # YOLOv8 segmentation model
+    """Configuration for the face detector."""
+    min_confidence: float = 0.5
+    model_path: str = "yolov8n-face.pt"
 
 @dataclass
 class AppConfig:
+    """Main application configuration."""
     blur: BlurConfig = field(default_factory=BlurConfig)
     detection: DetectionConfig = field(default_factory=DetectionConfig)
     scaling_factor: float = 1.2
@@ -47,91 +74,122 @@ class AppConfig:
     face_margin: int = 15
 
 # ====================================================
-# BLUR EFFECTS
+# BLUR EFFECTS (STRATEGY PATTERN)
 # ====================================================
 class BlurEffect(ABC):
+    """Abstract base class for blur effects."""
     def __init__(self, config: BlurConfig):
         self.config = config
 
     @abstractmethod
     def apply(self, image: np.ndarray, roi: Tuple[int, int, int, int]) -> np.ndarray:
+        """Apply the blur effect to the region of interest (ROI)."""
         pass
 
 class GaussianBlur(BlurEffect):
+    """Gaussian blur with adaptive kernel sizing for a natural look."""
     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 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)
+            # Intensity now directly maps to kernel size percentage
+            kernel_val = int(min_dim * (self.config.intensity / 100.0))
             kernel_val = max(self.config.min_kernel, min(kernel_val, self.config.max_kernel))
         else:
-            kernel_val = 45
-        kernel_val = kernel_val | 1
+            kernel_val = int(self.config.intensity)
+        
+        kernel_val = kernel_val | 1  # Ensure kernel size is odd
         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):
+    """Pixelation effect for a retro/digital privacy look."""
     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
+        if face_roi.size == 0: return image
+
+        h_roi, w_roi = face_roi.shape[:2]
         pixel_size = self.config.pixel_size
-        if pixel_size <= 0:
-            return image
+        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):
+    """Solid color rectangle overlay for complete redaction."""
     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}")
+    """Factory function to create a blur effect instance."""
+    blur_effects = {"gaussian": GaussianBlur, "pixelate": PixelateBlur, "solid": SolidColorBlur}
+    blur_class = blur_effects.get(config.type)
+    if not blur_class: raise ValueError(f"Unknown blur type: {config.type}")
+    return blur_class(config)
 
 # ====================================================
-# YOLOv8 DETECTOR
+# YOLOv8 FACE DETECTOR (SINGLETON)
 # ====================================================
-class YOLOv8Detector:
+class YOLOv8FaceDetector:
+    """Unified face detector using YOLOv8-Face model."""
     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)
+        try:
+            logger.info(f"Attempting to load YOLOv8-Face model: {config.model_path}")
+            self.model = YOLO(config.model_path)
+            self.min_conf = config.min_confidence
+            logger.info("✅ Model loaded successfully.")
+        except Exception as e:
+            logger.error(f"❌ Failed to load model: {e}")
+            raise RuntimeError(f"Model loading failed. Ensure '{config.model_path}' is available.") from e
+
+    def detect_faces(self, image: np.ndarray, conf_threshold: float, return_annotated: bool = False) -> Tuple[List[Dict[str, Any]], Optional[np.ndarray]]:
+        """Detects faces in an image with a given confidence threshold."""
+        results = self.model(image, conf=conf_threshold, verbose=False)
         faces = []
+        annotated_image = image.copy() if return_annotated else None
+
         for r in results:
+            if r.boxes is None: continue
             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
+                x1, y1, x2, y2 = map(int, box.xyxy[0])
+                confidence = float(box.conf[0])
+                faces.append({"x": x1, "y": y1, "width": x2 - x1, "height": y2 - y1, "confidence": confidence})
+                if return_annotated:
+                    cv2.rectangle(annotated_image, (x1, y1), (x2, y2), (0, 255, 0), 3)
+                    label = f"Face: {confidence:.2%}"
+                    (w, h), _ = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, 0.6, 2)
+                    cv2.rectangle(annotated_image, (x1, y1 - h - 10), (x1 + w, y1), (0, 255, 0), -1)
+                    cv2.putText(annotated_image, label, (x1, y1 - 5), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 0), 2)
+        return faces, annotated_image
+
+GLOBAL_DETECTOR: Optional[YOLOv8FaceDetector] = None
+def get_global_detector() -> YOLOv8FaceDetector:
+    """Initializes and returns the global singleton detector instance."""
+    global GLOBAL_DETECTOR
+    if GLOBAL_DETECTOR is None:
+        GLOBAL_DETECTOR = YOLOv8FaceDetector(DetectionConfig())
+    return GLOBAL_DETECTOR
 
 # ====================================================
-# MAIN APPLICATION
+# CORE APPLICATION LOGIC
 # ====================================================
 class FacePrivacyApp:
-    def __init__(self, config: AppConfig):
+    def __init__(self, config: AppConfig, detector: YOLOv8FaceDetector):
         self.config = config
         self.blur_effect = get_blur_effect(config.blur)
-        self.detector = YOLOv8Detector(config.detection)
+        self.detector = detector
 
     def _expand_bbox(self, bbox: Dict[str, Any], img_shape: Tuple[int, int]) -> Tuple[int, int, int, int]:
+        """Expands a bounding box to include margins for better coverage."""
         h_img, w_img = img_shape
         new_w = int(bbox["width"] * self.config.scaling_factor)
         new_h = int(bbox["height"] * self.config.scaling_factor)
@@ -143,113 +201,236 @@ class FacePrivacyApp:
         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:
+    def process_image(self, image: np.ndarray, conf_threshold: float) -> np.ndarray:
+        """Applies blur to all detected faces in an image."""
         writable_image = image.copy()
-        faces = self.detector.detect_faces(writable_image)
+        faces, _ = self.detector.detect_faces(writable_image, conf_threshold, return_annotated=False)
         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
+# GRADIO HANDLER FUNCTIONS
 # ====================================================
-def process_video_fn(video_file, blur_type, blur_amount, blur_size):
-    if video_file is None:
-        return None
-
+def get_app_instance(blur_type: str, blur_amount: float, blur_size: float) -> FacePrivacyApp:
+    """Creates a FacePrivacyApp instance from UI settings."""
+    detector = get_global_detector()
     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"))
+    return FacePrivacyApp(app_config, detector)
+
+def process_media(media, blur_type, blur_amount, blur_size, confidence):
+    if media is None: return None
+    try:
+        app = get_app_instance(blur_type, blur_amount, blur_size)
+        return app.process_image(media, confidence)
+    except Exception as e:
+        logger.error(f"Image processing error: {e}")
+        gr.Warning(f"An error occurred: {e}")
+        return media
+
+def process_video(video_file, blur_type, blur_amount, blur_size, confidence, progress=gr.Progress()):
+    if video_file is None: return None, "⚠️ No video provided."
+    try:
+        app = get_app_instance(blur_type, blur_amount, blur_size)
+        cap = cv2.VideoCapture(video_file.name)
+        if not cap.isOpened(): return None, "❌ Cannot open video file."
+
+        out_path = create_temp_file()
+        fourcc = cv2.VideoWriter_fourcc(*'avc1') # H.264 for browser compatibility
+        fps, w, h = cap.get(cv2.CAP_PROP_FPS), int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)), int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        out_vid = cv2.VideoWriter(out_path, fourcc, fps, (w, h))
+        if not out_vid.isOpened():
+            logger.warning("H.264 codec failed, falling back to mp4v.")
+            out_vid = cv2.VideoWriter(out_path, cv2.VideoWriter_fourcc(*'mp4v'), fps, (w, h))
+
+        frame_num = 0
+        while cap.isOpened():
+            ret, frame = cap.read()
+            if not ret: break
+            frame_num += 1
+            progress(frame_num / max(total_frames, 1), desc=f"Processing frame {frame_num}/{total_frames}")
+            processed_frame = app.process_image(frame, confidence)
+            out_vid.write(processed_frame)
+        cap.release()
+        out_vid.release()
+        return out_path, f"✅ Processed {frame_num} frames."
+    except Exception as e:
+        logger.error(f"Video processing error: {e}")
+        gr.Error(f"Video processing failed: {e}")
+        return None, f"❌ Error: {e}"
+
+def detect_faces_image(image, confidence):
+    if image is None: return None, "⚠️ No image provided."
+    try:
+        detector = get_global_detector()
+        faces, annotated_image = detector.detect_faces(image, confidence, return_annotated=True)
+        if faces:
+            result = f"✅ **{len(faces)} face(s) detected!**\n\n" + "\n".join([f"- Face {i+1}: Confidence {f['confidence']:.2%}" for i, f in enumerate(faces)])
+        else:
+            result = "❌ **No faces detected.**"
+        return annotated_image, result
+    except Exception as e:
+        logger.error(f"Image detection error: {e}")
+        gr.Warning(f"An error occurred: {e}")
+        return image, f"❌ Error: {e}"
+
+def detect_faces_video(video_file, confidence, progress=gr.Progress()):
+    if video_file is None: return None, "⚠️ No video provided."
+    try:
+        detector = get_global_detector()
+        cap = cv2.VideoCapture(video_file.name)
+        if not cap.isOpened(): return None, "❌ Cannot open video file."
+
+        out_path = create_temp_file()
+        fourcc = cv2.VideoWriter_fourcc(*'avc1')
+        fps, w, h = cap.get(cv2.CAP_PROP_FPS), int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)), int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        out_vid = cv2.VideoWriter(out_path, fourcc, fps, (w,h))
+        if not out_vid.isOpened(): out_vid = cv2.VideoWriter(out_path, cv2.VideoWriter_fourcc(*'mp4v'), fps, (w,h))
+
+        frame_num, frames_with_faces, all_confidences = 0, 0, []
+        while cap.isOpened():
+            ret, frame = cap.read()
+            if not ret: break
+            frame_num += 1
+            progress(frame_num / max(total_frames, 1), desc=f"Analyzing frame {frame_num}/{total_frames}")
+            faces, annotated_frame = detector.detect_faces(frame, confidence, return_annotated=True)
+            if faces:
+                frames_with_faces += 1
+                all_confidences.extend([f["confidence"] for f in faces])
+            out_vid.write(annotated_frame)
+        cap.release()
+        out_vid.release()
+        
+        if frames_with_faces > 0:
+            avg_conf = sum(all_confidences) / len(all_confidences)
+            result = (f"✅ **Faces detected in {frames_with_faces}/{frame_num} frames!**\n"
+                      f"📈 Average Confidence: **{avg_conf:.2%}**\n"
+                      f"🎯 Max Confidence: **{max(all_confidences):.2%}**")
+        else:
+            result = f"❌ **No faces detected in {frame_num} frames.**"
+        return out_path, result
+    except Exception as e:
+        logger.error(f"Video detection error: {e}")
+        gr.Error(f"Video detection failed: {e}")
+        return None, f"❌ Error: {e}"
+
+def detect_faces_webcam(image, confidence):
+    if image is None: return None
+    try:
+        detector = get_global_detector()
+        _, annotated_image = detector.detect_faces(image, confidence, return_annotated=True)
+        return annotated_image
+    except Exception as e:
+        logger.error(f"Webcam detection error: {e}")
+        return image
 
 # ====================================================
-# BUILD GRADIO APP
+# GRADIO UI
 # ====================================================
-with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# Face Privacy Tool (YOLOv8 Segmentation & Video)")
+with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue"), title="Face Privacy Tool") as demo:
+    gr.Markdown("# 🔐 Face Privacy Tool")
+    gr.Markdown("AI-powered face detection and privacy protection using **YOLOv8-Face**. Obscure faces in images, videos, and live webcam feeds, or use the detection mode to verify their presence.")
 
     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)")
+            gr.Markdown("### ⚙️ Global Settings")
+            with gr.Accordion("Privacy Settings", open=True):
+                blur_type = gr.Radio(["gaussian", "pixelate", "solid"], value="pixelate", label="Blur Type", info="Choose how to obscure faces.")
+                blur_amount = gr.Slider(1, 100, step=1, value=25, label="Blur Intensity/Size", info="Higher = more obscured.")
+                blur_size = gr.Slider(1.0, 2.0, step=0.05, value=1.2, label="Coverage Area", info="Expand blur beyond face boundary.")
+            with gr.Accordion("Detection Settings", open=True):
+                detection_confidence = gr.Slider(0.1, 0.9, step=0.05, value=0.5, label="Detection Threshold", info="Lower = more sensitive, but more false positives.")
 
         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)
+                with gr.TabItem("🔒 Privacy Mode (Blur Faces)"):
+                    gr.Markdown("### Apply privacy protection to your media.")
+                    with gr.Tabs():
+                        with gr.TabItem("📷 Image"):
+                            with gr.Row():
+                                img_in_blur = gr.Image(sources=["upload", "clipboard"], type="numpy", label="Input Image")
+                                img_out_blur = gr.Image(type="numpy", label="Protected Image")
+                            with gr.Row():
+                                blur_img_btn = gr.Button("Apply Privacy Blur", variant="primary", scale=3)
+                                gr.ClearButton([img_in_blur, img_out_blur], scale=1)
+                            gr.Examples(examples=[["./examples/group_photo.jpg"], ["./examples/single_person.jpg"]], inputs=img_in_blur)
+
+                        with gr.TabItem("🎥 Video"):
+                            with gr.Row():
+                                vid_in_blur = gr.File(file_types=[".mp4", ".mov", ".avi"], label="Input Video")
+                                with gr.Column():
+                                    vid_out_blur = gr.Video(label="Protected Video")
+                                    vid_status_blur = gr.Markdown("")
+                            with gr.Row():
+                                blur_vid_btn = gr.Button("Process Video", variant="primary", scale=3)
+                                gr.ClearButton([vid_in_blur, vid_out_blur, vid_status_blur], scale=1)
+
+                        with gr.TabItem("📹 Webcam"):
+                            gr.Markdown("**Real-time privacy protection from your webcam feed.**")
+                            with gr.Row():
+                                web_in_blur = gr.Image(sources=["webcam"], type="numpy", streaming=True, label="Live Webcam")
+                                web_out_blur = gr.Image(type="numpy", label="Protected Feed")
+
+                with gr.TabItem("🔍 Detection Mode (Check for Faces)"):
+                    gr.Markdown("### Verify if your media contains human faces.")
+                    with gr.Tabs():
+                        with gr.TabItem("📷 Image"):
+                            with gr.Row():
+                                img_in_detect = gr.Image(sources=["upload", "clipboard"], type="numpy", label="Input Image")
+                                with gr.Column():
+                                    img_out_detect = gr.Image(type="numpy", label="Detection Result")
+                                    img_status_detect = gr.Markdown("_Upload an image to start._")
+                            with gr.Row():
+                                detect_img_btn = gr.Button("Detect Faces", variant="primary", scale=3)
+                                gr.ClearButton([img_in_detect, img_out_detect, img_status_detect], scale=1)
+                            gr.Examples(examples=[["./examples/group_photo.jpg"], ["./examples/no_face.jpg"]], inputs=img_in_detect)
+
+                        with gr.TabItem("🎥 Video"):
+                            with gr.Row():
+                                vid_in_detect = gr.File(file_types=[".mp4", ".mov", ".avi"], label="Input Video")
+                                with gr.Column():
+                                    vid_out_detect = gr.Video(label="Annotated Video")
+                                    vid_status_detect = gr.Markdown("_Upload a video to start._")
+                            with gr.Row():
+                                detect_vid_btn = gr.Button("Analyze Video for Faces", variant="primary", scale=3)
+                                gr.ClearButton([vid_in_detect, vid_out_detect, vid_status_detect], scale=1)
+
+                        with gr.TabItem("📹 Webcam"):
+                            gr.Markdown("**Live face detection from your webcam feed.**")
+                            with gr.Row():
+                                web_in_detect = gr.Image(sources=["webcam"], type="numpy", streaming=True, label="Live Feed")
+                                web_out_detect = gr.Image(type="numpy", label="Detection Result")
+
+    # --- Event Handlers ---
+    # Privacy Mode
+    blur_img_btn.click(process_media, inputs=[img_in_blur, blur_type, blur_amount, blur_size, detection_confidence], outputs=img_out_blur)
+    blur_vid_btn.click(process_video, inputs=[vid_in_blur, blur_type, blur_amount, blur_size, detection_confidence], outputs=[vid_out_blur, vid_status_blur])
+    web_in_blur.stream(process_media, inputs=[web_in_blur, blur_type, blur_amount, blur_size, detection_confidence], outputs=web_out_blur)
+    
+    # Detection Mode
+    detect_img_btn.click(detect_faces_image, inputs=[img_in_detect, detection_confidence], outputs=[img_out_detect, img_status_detect])
+    detect_vid_btn.click(detect_faces_video, inputs=[vid_in_detect, detection_confidence], outputs=[vid_out_detect, vid_status_detect])
+    web_in_detect.stream(detect_faces_webcam, inputs=[web_in_detect, detection_confidence], outputs=web_out_detect)
+
+    # Footer
+    gr.Markdown("---")
+    gr.Markdown("🤖 **Powered by YOLOv8-Face** | Built with Gradio & OpenCV | ⚡ Optimized for performance with a global model singleton.")
 
+# ====================================================
+# MAIN ENTRY POINT
+# ====================================================
 if __name__ == "__main__":
-    demo.launch()
+    logger.info("🚀 Initializing Face Privacy Tool...")
+    try:
+        get_global_detector()
+        logger.info("✅ Systems ready. Launching Gradio interface...")
+        demo.launch()
+    except Exception as e:
+        logger.error(f"❌ Startup failed: {e}")
+        logger.info("💡 Make sure 'yolov8n-face.pt' is available in the current directory or will be downloaded automatically by ultralytics.")