opu

app.py

@@ -1,314 +1,1070 @@
 """
-Redact & Reveal – Zero-Trust Face Privacy
-Every face is permanently blurred · Known people are labeled · Unknown = red "Unknown"
-Image · Video · Live Webcam · Falls back safely if recognition fails
+Unified Face Tool - Detection + Privacy + Smart Privacy with Recognition
+Combined system with 3 modes: Detection, Blur, and Smart Blur with Identification
 """
 
+# --- Standard Libraries ---
 import logging
 import atexit
 import tempfile
 import os
+import hashlib
+from abc import ABC, abstractmethod
 from dataclasses import dataclass, field
 from typing import Any, Dict, List, Tuple, Optional
 from pathlib import Path
-import hashlib
 
+# --- Computer Vision & UI Libraries ---
 import cv2
 import numpy as np
 import gradio as gr
 from ultralytics import YOLO
 
-# Optional recognition deps (graceful fallback)
+# --- Face Recognition Libraries (Optional) ---
 try:
     from deepface import DeepFace
     DEEPFACE_AVAILABLE = True
 except ImportError:
     DEEPFACE_AVAILABLE = False
+    logging.warning("⚠️ DeepFace not installed - recognition features will fallback to 'Unknown'")
 
 try:
     import chromadb
     CHROMADB_AVAILABLE = True
 except ImportError:
     CHROMADB_AVAILABLE = False
+    logging.warning("⚠️ ChromaDB not installed - recognition features will fallback to 'Unknown'")
 
+# --- Configure Logging ---
 logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
 logger = logging.getLogger(__name__)
 
 # ====================================================
-# TEMP FILE CLEANUP
+# 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)
-        except: pass
+            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"):
+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
 
 # ====================================================
-# CONFIG
+# SENSITIVITY MAPPING
 # ====================================================
-SENSITIVITY_MAP = {"Low (Catch More)": 0.3, "Balanced (Default)": 0.5, "High (Very Strict)": 0.7}
-def get_confidence(sensitivity: str) -> float:
+SENSITIVITY_MAP = {
+    "Low (Catch More)": 0.3,
+    "Balanced (Default)": 0.5,
+    "High (Very Strict)": 0.7
+}
+
+def get_confidence_from_sensitivity(sensitivity: str) -> float:
+    """Converts user-friendly sensitivity text to numerical confidence threshold."""
     return SENSITIVITY_MAP.get(sensitivity, 0.5)
 
+# ====================================================
+# CONFIGURATION DATA CLASSES
+# ====================================================
+@dataclass
+class BlurConfig:
+    """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
+    max_kernel: int = 95
+
+@dataclass
+class DetectionConfig:
+    """Configuration for the face detector."""
+    min_confidence: float = 0.5
+    model_path: str = "yolov8n-face.pt"
+
 @dataclass
 class AppConfig:
-    scaling_factor: float = 1.25
-    forehead_margin: int = 30
-    face_margin: int = 20
-    blur_type: str = "pixelate"
-    blur_intensity: float = 30
-    pixel_size: int = 30
+    """Main application configuration."""
+    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
+# BLUR EFFECTS (STRATEGY PATTERN)
 # ====================================================
-class BlurEffect:
-    def __init__(self, config: AppConfig):
+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 self.config.adaptive_blur:
+            min_dim = min(w, h)
+            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 = 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[:2]
+        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):
+    """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
-        face = image[y:y+h, x:x+w]
-        if face.size == 0: return image
-
-        if self.config.blur_type == "gaussian":
-            k = int(min(w, h) * (self.config.blur_intensity / 100))
-            k = max(15, k | 1)
-            blurred = cv2.GaussianBlur(face, (k, k), 0)
-        else:  # pixelate (default & best looking)
-            ps = max(10, int(self.config.pixel_size))
-            small = cv2.resize(face, (max(1, w//ps), max(1, h//ps)), interpolation=cv2.INTER_LINEAR)
-            blurred = cv2.resize(small, (w, h), interpolation=cv2.INTER_NEAREST)
-
-        image[y:y+h, x:x+w] = blurred
+        cv2.rectangle(image, (x, y), (x+w, y+h), self.config.solid_color, -1)
         return image
 
+def get_blur_effect(config: BlurConfig) -> BlurEffect:
+    """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)
+
 # ====================================================
-# DATABASE (HIDDEN, PERSISTENT, MULTI-IMAGE)
+# FACE DATABASE (Simplified, no UI)
 # ====================================================
-class FaceDatabase:
-    def __init__(self):
-        self.dir = Path("known_faces")
-        self.dir.mkdir(exist_ok=True)
-        self.client = chromadb.PersistentClient(path="./chroma_db") if CHROMADB_AVAILABLE else None
-        self.collection = self.client.get_or_create_collection("faces") if self.client else None
-        self._index_existing()
-
-    def _index_existing(self):
-        if not CHROMADB_AVAILABLE or not DEEPFACE_AVAILABLE: return
-        for person_dir in self.dir.iterdir():
-            if not person_dir.is_dir(): continue
-            parts = person_dir.name.split("_", 1)
-            if len(parts) != 2: continue
-            pid, pname = parts
-            pname = pname.replace("_", " ").title()
-            for img_path in person_dir.glob("*.jpg"):
+class SimpleFaceDatabase:
+    """Simplified face recognition system using ChromaDB - backend only."""
+    
+    def __init__(
+        self, 
+        known_faces_dir: str = "known_faces",
+        db_path: str = "./chroma_db",
+        model_name: str = "Facenet512"
+    ):
+        self.known_faces_dir = Path(known_faces_dir)
+        self.model_name = model_name
+        self.db_path = db_path
+        self.available = CHROMADB_AVAILABLE and DEEPFACE_AVAILABLE
+        
+        if not self.available:
+            logger.warning("⚠️ Face recognition not available - will use 'Unknown' labels")
+            self.client = None
+            self.collection = None
+            return
+        
+        # Initialize ChromaDB
+        logger.info("🔧 Initializing face recognition database...")
+        try:
+            self.client = chromadb.PersistentClient(path=db_path)
+            self.collection = self.client.get_or_create_collection(
+                name="face_embeddings",
+                metadata={"hnsw:space": "cosine"}
+            )
+            
+            existing_count = self.collection.count()
+            logger.info(f"📊 Database contains {existing_count} face embeddings")
+            
+            if self.known_faces_dir.exists():
+                self._index_faces_from_folders()
+            else:
+                self.known_faces_dir.mkdir(parents=True, exist_ok=True)
+                
+        except Exception as e:
+            logger.error(f"❌ Database initialization failed: {e}")
+            self.available = False
+            self.client = None
+            self.collection = None
+    
+    def _get_image_hash(self, img_path: Path) -> str:
+        """Generate unique hash for an image."""
+        with open(img_path, 'rb') as f:
+            return hashlib.md5(f.read()).hexdigest()
+    
+    def _index_faces_from_folders(self):
+        """Auto-index faces from known_faces/ folder structure."""
+        logger.info("🔄 Scanning for faces to index...")
+        
+        person_dirs = [d for d in self.known_faces_dir.iterdir() if d.is_dir()]
+        indexed_count = 0
+        
+        for person_dir in person_dirs:
+            folder_name = person_dir.name
+            parts = folder_name.split('_', 1)
+            
+            if len(parts) != 2:
+                logger.warning(f"⚠️ Skipping '{folder_name}' - use format: 'ID_Name'")
+                continue
+            
+            person_id, person_name = parts
+            person_name = person_name.replace('_', ' ').title()
+            
+            image_files = list(person_dir.glob("*.jpg")) + \
+                         list(person_dir.glob("*.png")) + \
+                         list(person_dir.glob("*.jpeg"))
+            
+            for img_path in image_files:
                 try:
-                    emb = DeepFace.represent(str(img_path), model_name="Facenet512", enforce_detection=False)[0]["embedding"]
-                    hash_id = hashlib.md5(open(img_path, "rb").read()).hexdigest()
-                    if not self.collection.get(ids=[hash_id])["ids"]:
-                        self.collection.add(
-                            embeddings=[emb],
-                            metadatas=[{"person_id": pid, "name": pname}],
-                            ids=[hash_id]
-                        )
-                except: pass
-
-    def add_person(self, person_id: str, name: str, images: List[np.ndarray]):
-        if not (CHROMADB_AVAILABLE and DEEPFACE_AVAILABLE): 
-            return "⚠️ Recognition disabled – person saved locally only"
+                    img_hash = self._get_image_hash(img_path)
+                    existing = self.collection.get(ids=[img_hash], include=[])
+                    
+                    if existing['ids']:
+                        continue
+                    
+                    embedding_obj = DeepFace.represent(
+                        img_path=str(img_path),
+                        model_name=self.model_name,
+                        enforce_detection=False
+                    )
+                    
+                    if not embedding_obj:
+                        continue
+                    
+                    embedding = embedding_obj[0]["embedding"]
+                    
+                    self.collection.add(
+                        embeddings=[embedding],
+                        documents=[str(img_path)],
+                        metadatas=[{
+                            "person_id": person_id,
+                            "person_name": person_name,
+                            "image_file": img_path.name
+                        }],
+                        ids=[img_hash]
+                    )
+                    
+                    indexed_count += 1
+                    logger.info(f"✅ Indexed: {person_name} (ID: {person_id})")
+                    
+                except Exception as e:
+                    logger.error(f"❌ Failed to index {img_path}: {e}")
+        
+        if indexed_count > 0:
+            logger.info(f"💾 Indexed {indexed_count} new face(s)")
+    
+    def recognize_face(self, face_image: np.ndarray, threshold: float = 0.45) -> Dict[str, Any]:
+        """Recognize a face using ChromaDB vector search."""
+        if not self.available or self.collection is None or self.collection.count() == 0:
+            return {"match": False, "person_id": "unknown", "name": "Unknown"}
         
-        folder = self.dir / f"{person_id}_{name.lower().replace(' ', '_')}"
-        folder.mkdir(exist_ok=True)
-        added = 0
-        for i, img in enumerate(images):
-            path = folder / f"{person_id}_{len(list(folder.glob('*.jpg')))+1}.jpg"
-            cv2.imwrite(str(path), cv2.cvtColor(img, cv2.COLOR_RGB2BGR))
-            try:
-                emb = DeepFace.represent(str(path), model_name="Facenet512", enforce_detection=False)[0]["embedding"]
-                hash_id = hashlib.md5(open(path, "rb").read()).hexdigest()
-                self.collection.add(
-                    embeddings=[emb],
-                    metadatas=[{"person_id": person_id, "name": name.title()}],
-                    ids=[hash_id]
-                )
-                added += 1
-            except: pass
-        return f"✅ Added {added} photo(s) for {name} (ID: {person_id})"
-
-    def recognize(self, face_crop: np.ndarray) -> Dict[str, Any]:
-        if not (CHROMADB_AVAILABLE and DEEPFACE_AVAILABLE and self.collection and self.collection.count() > 0):
-            return {"match": False, "name": "Unknown", "person_id": "unknown"}
         try:
-            temp_path = "temp_recog.jpg"
-            cv2.imwrite(temp_path, cv2.cvtColor(face_crop, cv2.COLOR_RGB2BGR))
-            emb = DeepFace.represent(temp_path, model_name="Facenet512", enforce_detection=False)[0]["embedding"]
-            os.remove(temp_path)
-            results = self.collection.query(query_embeddings=[emb], n_results=1, include=["metadatas", "distances"])
-            if results["distances"][0][0] < 0.45:
-                meta = results["metadatas"][0][0]
-                return {"match": True, "name": meta["name"], "person_id": meta["person_id"]}
-        except: pass
-        return {"match": False, "name": "Unknown", "person_id": "unknown"}
-
-DB = FaceDatabase() if (CHROMADB_AVAILABLE or not DEEPFACE_AVAILABLE) else None
+            temp_path = "temp_face.jpg"
+            cv2.imwrite(temp_path, cv2.cvtColor(face_image, cv2.COLOR_RGB2BGR))
+            
+            embedding_obj = DeepFace.represent(
+                img_path=temp_path,
+                model_name=self.model_name,
+                enforce_detection=False
+            )
+            
+            if os.path.exists(temp_path):
+                os.remove(temp_path)
+            
+            if not embedding_obj:
+                return {"match": False, "person_id": "unknown", "name": "Unknown"}
+            
+            face_embedding = embedding_obj[0]["embedding"]
+            
+            results = self.collection.query(
+                query_embeddings=[face_embedding],
+                n_results=1,
+                include=["metadatas", "distances"]
+            )
+            
+            if not results['ids'][0]:
+                return {"match": False, "person_id": "unknown", "name": "Unknown"}
+            
+            distance = results['distances'][0][0]
+            metadata = results['metadatas'][0][0]
+            
+            if distance < threshold:
+                return {
+                    "match": True,
+                    "person_id": metadata['person_id'],
+                    "name": metadata['person_name']
+                }
+            
+            return {"match": False, "person_id": "unknown", "name": "Unknown"}
+                
+        except Exception as e:
+            logger.error(f"❌ Recognition error: {e}")
+            return {"match": False, "person_id": "unknown", "name": "Unknown"}
+
+# Global database instance
+FACE_DB: Optional[SimpleFaceDatabase] = None
+
+def get_face_database() -> SimpleFaceDatabase:
+    """Get or create the global face database."""
+    global FACE_DB
+    if FACE_DB is None:
+        FACE_DB = SimpleFaceDatabase()
+    return FACE_DB
 
 # ====================================================
-# UNIFIED DETECTOR + BLUR + LABEL
+# UNIFIED YOLO DETECTOR
 # ====================================================
-class RedactReveal:
-    def __init__(self):
-        self.model = YOLO("yolov8n-face.pt")
-        self.blur = BlurEffect(AppConfig())
-
-    def _expand_roi(self, face: Dict, h: int, w: int) -> Tuple[int,int,int,int]:
-        x, y, fw, fh = face["x"], face["y"], face["width"], face["height"]
-        scale = AppConfig.scaling_factor
-        new_w, new_h = int(fw * scale), int(fh * scale)
-        dx, dy = (new_w - fw) // 2, (new_h - fh) // 2
-        return (
-            max(0, x - dx - AppConfig.face_margin),
-            max(0, y - dy - AppConfig.forehead_margin),
-            min(w - max(0, x - dx - AppConfig.face_margin), new_w + 2*AppConfig.face_margin),
-            min(h - max(0, y - dy - AppConfig.forehead_margin), new_h + AppConfig.forehead_margin + 40)
-        )
-
-    def process_frame(self, frame: np.ndarray, conf_threshold: float) -> np.ndarray:
-        results = self.model(frame, conf=conf_threshold, verbose=False)
-        img = frame.copy()
-        known = unknown = 0
+class UnifiedYOLODetector:
+    """Unified face detector using YOLOv8-Face model."""
+    def __init__(self, config: DetectionConfig):
+        try:
+            logger.info(f"📦 Loading 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,
+        recognize: bool = False,
+        return_face_info: bool = True
+    ) -> Tuple[List[Dict[str, Any]], Optional[np.ndarray]]:
+        """Detects faces with optional annotation and recognition."""
+        results = self.model(image, conf=conf_threshold, verbose=False)
+        faces = []
+        annotated_image = image.copy() if return_annotated else None
+        
+        # Get face database for recognition if needed
+        face_db = get_face_database() if recognize else None
 
         for r in results:
-            if r.boxes is None: continue
+            if r.boxes is None: 
+                continue
             for box in r.boxes:
                 x1, y1, x2, y2 = map(int, box.xyxy[0])
-                face_info = {"x": x1, "y": y1, "width": x2-x1, "height": y2-y1}
-                roi = self._expand_roi(face_info, img.shape[0], img.shape[1])
-                img = self.blur.apply(img, roi)
-
-                # Recognition
-                crop = frame[y1:y2, x1:x2]
-                rec = DB.recognize(crop) if DB and crop.size > 0 else {"match": False, "name": "Unknown", "person_id": "unknown"}
-                if rec["match"]:
-                    label = f"{rec['name']} · {rec['person_id']}"
-                    color = (0, 255, 0)  # green
-                    known += 1
-                else:
-                    label = "Unknown"
-                    color = (0, 0, 255)  # red
-                    unknown += 1
-
-                # Professional label on face
-                font_scale = max(0.7, min(face_info["width"]/200, 2.0))
-                thickness = 2
-                (tw, th), _ = cv2.getTextSize(label, cv2.FONT_HERSHEY_DUPLEX, font_scale, thickness)
-                center_x = x1 + face_info["width"] // 2
-                label_y = y1 + face_info["height"] // 2 + th // 2
-
-                cv2.rectangle(img, (center_x - tw//2 - 10, label_y - th - 10),
-                              (center_x + tw//2 + 10, label_y + 10), (0, 0, 0, 180), -1)
-                cv2.putText(img, label, (center_x - tw//2, label_y),
-                            cv2.FONT_HERSHEY_DUPLEX, font_scale, (255, 255, 255), thickness)
-
-        # Counter
-        summary = f"{known + unknown} faces protected · {known} known · {unknown} unknown"
-        if not (DEEPFACE_AVAILABLE and CHROMADB_AVAILABLE):
-            summary += " · Recognition offline"
-        cv2.putText(img, summary, (15, 45), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (255, 255, 255), 2)
-        cv2.putText(img, summary, (13, 43), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 0, 0), 2)
-
-        return img
-
-processor = RedactReveal()
+                confidence = float(box.conf[0])
+                
+                face_info = {
+                    "x": x1, "y": y1, 
+                    "width": x2 - x1, 
+                    "height": y2 - y1, 
+                    "confidence": confidence
+                }
+                
+                # Add recognition if requested
+                if recognize and face_db:
+                    face_crop = image[y1:y2, x1:x2]
+                    if face_crop.size > 0:
+                        recognition_result = face_db.recognize_face(face_crop)
+                        face_info.update(recognition_result)
+                    else:
+                        face_info.update({"match": False, "person_id": "unknown", "name": "Unknown"})
+                
+                faces.append(face_info)
+                
+                # Draw annotations if requested (Detection mode)
+                if return_annotated and not recognize:
+                    cv2.rectangle(annotated_image, (x1, y1), (x2, y2), (0, 255, 0), 3)
+                    label = "Face"
+                    (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[UnifiedYOLODetector] = None
+
+def get_global_detector() -> UnifiedYOLODetector:
+    """Initializes and returns the global singleton detector instance."""
+    global GLOBAL_DETECTOR
+    if GLOBAL_DETECTOR is None:
+        GLOBAL_DETECTOR = UnifiedYOLODetector(DetectionConfig())
+    return GLOBAL_DETECTOR
+
+# ====================================================
+# SMART PRIVACY APPLICATION
+# ====================================================
+class SmartPrivacyApp:
+    """Application that combines blur and recognition."""
+    def __init__(self, config: AppConfig, detector: UnifiedYOLODetector):
+        self.config = config
+        self.blur_effect = get_blur_effect(config.blur)
+        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)
+        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_smart_privacy(self, image: np.ndarray, conf_threshold: float) -> Tuple[np.ndarray, str]:
+        """Process image with blur and recognition - the key innovation!"""
+        writable_image = image.copy()
+        
+        # Step 1: Detect and recognize faces
+        faces, _ = self.detector.detect_faces(writable_image, conf_threshold, recognize=True)
+        
+        # Build status message
+        known_count = sum(1 for f in faces if f.get("match", False))
+        unknown_count = len(faces) - known_count
+        
+        status = ""
+        if not DEEPFACE_AVAILABLE or not CHROMADB_AVAILABLE:
+            status = "⚠️ Recognition unavailable - all faces marked as Unknown\n"
+        
+        # Step 2: Blur ALL faces
+        for face in faces:
+            expanded_roi = self._expand_bbox(face, writable_image.shape[:2])
+            writable_image = self.blur_effect.apply(writable_image, expanded_roi)
+        
+        # Step 3: Add labels ON TOP of blurred faces
+        for face in faces:
+            x1, y1 = face["x"], face["y"]
+            width, height = face["width"], face["height"]
+            
+            # Determine label
+            if face.get("match", False):
+                label = f"{face['name']} ({face['person_id']})"
+                bg_color = (0, 200, 0)  # Green background for known
+            else:
+                label = "Unknown"
+                bg_color = (200, 0, 0)  # Red background for unknown
+            
+            # Draw label with background for readability
+            font = cv2.FONT_HERSHEY_SIMPLEX
+            font_scale = 0.6
+            thickness = 2
+            (text_width, text_height), baseline = cv2.getTextSize(label, font, font_scale, thickness)
+            
+            # Position label at top of face bbox
+            label_y = y1 - 5
+            if label_y - text_height < 0:  # If label goes off top, put it inside
+                label_y = y1 + text_height + 5
+            
+            # Draw background rectangle
+            cv2.rectangle(writable_image, 
+                         (x1, label_y - text_height - 5), 
+                         (x1 + text_width + 10, label_y + 5), 
+                         bg_color, -1)
+            
+            # Draw text
+            cv2.putText(writable_image, label, 
+                       (x1 + 5, label_y), 
+                       font, font_scale, (255, 255, 255), thickness)
+        
+        # Build summary
+        if faces:
+            status += f"✅ Processed {len(faces)} face(s): {known_count} known, {unknown_count} unknown"
+        else:
+            status = "❌ No faces detected"
+        
+        return writable_image, status
+
+    def process_simple_blur(self, image: np.ndarray, conf_threshold: float) -> np.ndarray:
+        """Simple blur without recognition (Privacy mode)."""
+        writable_image = image.copy()
+        faces, _ = self.detector.detect_faces(writable_image, conf_threshold, recognize=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
 
 # ====================================================
-# GRADIO HANDLERS
+# GRADIO HANDLER FUNCTIONS
 # ====================================================
-def process_image(img, sensitivity, blur_type, blur_intensity):
-    if img is None: return None
-    AppConfig.blur_type = blur_type
-    AppConfig.blur_intensity = blur_intensity
-    AppConfig.pixel_size = int(blur_intensity)
-    return processor.process_frame(img, get_confidence(sensitivity))
-
-def process_video(video, sensitivity, blur_type, blur_intensity, progress=gr.Progress()):
-    if video is None: return None, None
-    AppConfig.blur_type = blur_type
-    AppConfig.blur_intensity = blur_intensity
-    AppConfig.pixel_size = int(blur_intensity)
-
-    cap = cv2.VideoCapture(video.name)
-    fps = cap.get(cv2.CAP_PROP_FPS)
-    w, h = int(cap.get(3)), int(cap.get(4))
-    out_path = create_temp_file()
-    out = cv2.VideoWriter(out_path, cv2.VideoWriter_fourcc(*'mp4v'), fps, (w, h))
-
-    total = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-    i = 0
-    while cap.isOpened():
-        ret, frame = cap.read()
-        if not ret: break
-        i += 1
-        progress(i/total, desc=f"Processing {i}/{total}")
-        frame = processor.process_frame(frame, get_confidence("Balanced (Default)"))
-        out.write(frame)
-    cap.release(); out.release()
-    return out_path, "Done!"
-
-def add_person(person_id: str, name: str, images):
-    if not person_id or not name or not images:
-        return "Please fill all fields"
-    imgs = images if isinstance(images, list) else [images]
-    return DB.add_person(person_id.strip(), name.strip(), imgs)
+def get_app_instance(blur_type: str, blur_amount: float, blur_size: float) -> SmartPrivacyApp:
+    """Creates a SmartPrivacyApp 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))
+    )
+    return SmartPrivacyApp(app_config, detector)
+
+# ---- Detection Mode Handlers ----
+def detect_faces_image(image, sensitivity):
+    """Detect faces in single image."""
+    if image is None: 
+        return None, "⚠️ No image provided."
+    try:
+        confidence = get_confidence_from_sensitivity(sensitivity)
+        detector = get_global_detector()
+        faces, annotated_image = detector.detect_faces(image, confidence, return_annotated=True, recognize=False)
+        
+        if faces:
+            result = f"✅ **{len(faces)} face(s) detected!**"
+        else:
+            result = "❌ **No faces detected.**"
+        
+        return annotated_image, result
+    except Exception as e:
+        logger.error(f"Detection error: {e}")
+        return image, f"❌ Error: {e}"
+
+def detect_faces_video(video_file, sensitivity, progress=gr.Progress()):
+    """Detect faces in video."""
+    if video_file is None: 
+        return None, "⚠️ No video provided."
+    try:
+        confidence = get_confidence_from_sensitivity(sensitivity)
+        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(*'mp4v')
+        fps = cap.get(cv2.CAP_PROP_FPS)
+        w, h = 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))
+
+        frame_num, frames_with_faces = 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"Frame {frame_num}/{total_frames}")
+            faces, annotated_frame = detector.detect_faces(frame, confidence, return_annotated=True, recognize=False)
+            if faces:
+                frames_with_faces += 1
+            out_vid.write(annotated_frame)
+        
+        cap.release()
+        out_vid.release()
+        
+        if frames_with_faces > 0:
+            result = f"✅ **Faces detected in {frames_with_faces}/{frame_num} frames!**"
+        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}")
+        return None, f"❌ Error: {e}"
+
+def detect_faces_webcam(image, sensitivity):
+    """Detect faces in webcam stream."""
+    if image is None: 
+        return None
+    try:
+        confidence = get_confidence_from_sensitivity(sensitivity)
+        detector = get_global_detector()
+        _, annotated_image = detector.detect_faces(image, confidence, return_annotated=True, recognize=False)
+        return annotated_image
+    except Exception as e:
+        logger.error(f"Webcam detection error: {e}")
+        return image
+
+# ---- Privacy Mode Handlers (Blur only) ----
+def process_privacy_image(image, blur_type, blur_amount, blur_size, sensitivity):
+    """Process single image with blur effect only."""
+    if image is None: 
+        return None
+    try:
+        confidence = get_confidence_from_sensitivity(sensitivity)
+        app = get_app_instance(blur_type, blur_amount, blur_size)
+        return app.process_simple_blur(image, confidence)
+    except Exception as e:
+        logger.error(f"Privacy processing error: {e}")
+        return image
+
+def process_privacy_video(video_file, blur_type, blur_amount, blur_size, sensitivity, progress=gr.Progress()):
+    """Process video with blur effect only."""
+    if video_file is None: 
+        return None, "⚠️ No video provided."
+    try:
+        confidence = get_confidence_from_sensitivity(sensitivity)
+        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(*'mp4v')
+        fps = cap.get(cv2.CAP_PROP_FPS)
+        w, h = 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))
+
+        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_simple_blur(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}")
+        return None, f"❌ Error: {e}"
+
+def process_privacy_webcam(image, blur_type, blur_amount, blur_size, sensitivity):
+    """Process webcam stream with blur."""
+    if image is None: 
+        return None
+    try:
+        confidence = get_confidence_from_sensitivity(sensitivity)
+        app = get_app_instance(blur_type, blur_amount, blur_size)
+        return app.process_simple_blur(image, confidence)
+    except Exception as e:
+        logger.error(f"Webcam processing error: {e}")
+        return image
+
+# ---- Smart Privacy Mode Handlers (Blur + Identify) ----
+def process_smart_image(image, blur_type, blur_amount, blur_size, sensitivity):
+    """Process image with blur and identification."""
+    if image is None: 
+        return None, "⚠️ No image provided."
+    try:
+        confidence = get_confidence_from_sensitivity(sensitivity)
+        app = get_app_instance(blur_type, blur_amount, blur_size)
+        processed_image, status = app.process_smart_privacy(image, confidence)
+        return processed_image, status
+    except Exception as e:
+        logger.error(f"Smart processing error: {e}")
+        return image, f"❌ Error: {e}"
+
+def process_smart_video(video_file, blur_type, blur_amount, blur_size, sensitivity, progress=gr.Progress()):
+    """Process video with blur and identification."""
+    if video_file is None: 
+        return None, "⚠️ No video provided."
+    try:
+        confidence = get_confidence_from_sensitivity(sensitivity)
+        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(*'mp4v')
+        fps = cap.get(cv2.CAP_PROP_FPS)
+        w, h = 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))
+
+        frame_num = 0
+        total_known = 0
+        total_unknown = 0
+        
+        # Process frames (with temporal optimization for performance)
+        PROCESS_EVERY_N = 10  # Full recognition every 10 frames
+        cached_faces = []
+        
+        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}")
+            
+            # Process frame
+            if frame_num % PROCESS_EVERY_N == 1 or frame_num == 1:
+                # Full processing with recognition
+                processed_frame, _ = app.process_smart_privacy(frame, confidence)
+                detector = get_global_detector()
+                cached_faces, _ = detector.detect_faces(frame, confidence, recognize=True)
+                
+                # Count for statistics
+                for face in cached_faces:
+                    if face.get("match", False):
+                        total_known += 1
+                    else:
+                        total_unknown += 1
+            else:
+                # Use cached recognition results for performance
+                processed_frame = app.process_simple_blur(frame, confidence)
+                # Apply cached labels
+                for face in cached_faces:
+                    x1, y1 = face["x"], face["y"]
+                    
+                    if face.get("match", False):
+                        label = f"{face['name']} ({face['person_id']})"
+                        bg_color = (0, 200, 0)
+                    else:
+                        label = "Unknown"
+                        bg_color = (200, 0, 0)
+                    
+                    font = cv2.FONT_HERSHEY_SIMPLEX
+                    (text_width, text_height), _ = cv2.getTextSize(label, font, 0.6, 2)
+                    label_y = y1 - 5
+                    if label_y - text_height < 0:
+                        label_y = y1 + text_height + 5
+                    
+                    cv2.rectangle(processed_frame, 
+                                 (x1, label_y - text_height - 5), 
+                                 (x1 + text_width + 10, label_y + 5), 
+                                 bg_color, -1)
+                    cv2.putText(processed_frame, label, 
+                               (x1 + 5, label_y), 
+                               font, 0.6, (255, 255, 255), 2)
+            
+            out_vid.write(processed_frame)
+        
+        cap.release()
+        out_vid.release()
+        
+        status = f"✅ Processed {frame_num} frames.\n"
+        if not DEEPFACE_AVAILABLE or not CHROMADB_AVAILABLE:
+            status += "⚠️ Recognition unavailable - all faces marked as Unknown"
+        else:
+            status += f"Known faces: {total_known}, Unknown: {total_unknown}"
+        
+        return out_path, status
+    except Exception as e:
+        logger.error(f"Smart video processing error: {e}")
+        return None, f"❌ Error: {e}"
+
+def process_smart_webcam(image, blur_type, blur_amount, blur_size, sensitivity):
+    """Process webcam with blur and identification."""
+    if image is None: 
+        return None, None
+    try:
+        confidence = get_confidence_from_sensitivity(sensitivity)
+        app = get_app_instance(blur_type, blur_amount, blur_size)
+        processed_image, _ = app.process_smart_privacy(image, confidence)
+        return processed_image, None
+    except Exception as e:
+        logger.error(f"Smart webcam error: {e}")
+        return image, None
 
 # ====================================================
-# UI – ONE TAB TO RULE THEM ALL
+# GRADIO UI
 # ====================================================
-with gr.Blocks(title="Redact & Reveal – Zero-Trust Face Privacy", theme=gr.themes.Soft(primary_hue="red")) as demo:
-    gr.Markdown("# Redact & Reveal")
-    gr.Markdown("**Every face is permanently blurred · Known people are labeled · Unknown faces marked red**  \nWorks on photos, videos, and live webcam · Never exposes identity")
+with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue"), title="Unified Face Tool") as demo:
+    gr.Markdown("# 🎯 Unified Face Tool")
+    gr.Markdown("**Detection • Privacy • Smart Privacy** - AI-powered face processing using YOLOv8")
+    
+    # Recognition availability warning
+    if not DEEPFACE_AVAILABLE or not CHROMADB_AVAILABLE:
+        with gr.Row():
+            gr.Markdown("""
+            ⚠️ **Recognition features limited:** Install optional dependencies for full functionality:
+            ```bash
+            pip install deepface tf-keras chromadb
+            ```
+            *Smart Privacy will work but all faces will be labeled as 'Unknown'*
+            """)
 
     with gr.Row():
-        with gr.Column(scale=1):
-            gr.Markdown("### Settings")
-            sensitivity = gr.Radio(list(SENSITIVITY_MAP.keys()), value="Balanced (Default)", label="Detection Sensitivity")
-            blur_type = gr.Radio(["pixelate", "gaussian"], value="pixelate", label="Blur Style")
-            blur_intensity = gr.Slider(10, 80, 30, step=5, label="Blur Strength (higher = stronger)")
-
-            with gr.Accordion("➕ Add Person to Safe List (optional)", open=False):
-                gr.Markdown("**Take 3 quick photos**: front · turn left · turn right")
-                pid = gr.Textbox(label="Person ID", placeholder="001")
-                pname = gr.Textbox(label="Name", placeholder="John Doe")
-                photos = gr.Image(label="Upload 1–3 photos", sources=["upload", "webcam"], type="numpy", height=200)
-                add_btn = gr.Button("Add Person")
-                status = gr.Markdown()
-
-        with gr.Column(scale=2):
+        # ========== SETTINGS SIDEBAR ==========
+        with gr.Column(scale=1, variant="panel"):
+            gr.Markdown("### ⚙️ Settings")
+            
+            with gr.Accordion("Detection", open=True):
+                detection_sensitivity = gr.Radio(
+                    choices=list(SENSITIVITY_MAP.keys()),
+                    value="Balanced (Default)",
+                    label="Sensitivity",
+                    info="How strict face detection should be"
+                )
+            
+            with gr.Accordion("Privacy", open=True):
+                blur_type = gr.Radio(
+                    ["gaussian", "pixelate", "solid"], 
+                    value="pixelate", 
+                    label="Blur Type"
+                )
+                blur_amount = gr.Slider(
+                    1, 100, 
+                    step=1, 
+                    value=15, 
+                    label="Blur Intensity"
+                )
+                blur_size = gr.Slider(
+                    1.0, 2.0, 
+                    step=0.05, 
+                    value=1.1, 
+                    label="Coverage Area"
+                )
+
+        # ========== MAIN CONTENT ==========
+        with gr.Column(scale=3):
             with gr.Tabs():
-                with gr.Tab("Image"):
-                    img_in = gr.Image(type="numpy", label="Upload Photo", height=520)
-                    img_out = gr.Image(type="numpy", label="Protected Result", height=520)
-                    img_in.change(process_image, [img_in, sensitivity, blur_type, blur_intensity], img_out)
-
-                with gr.Tab("Video"):
-                    vid_in = gr.File(label="Upload Video", file_types=["video"])
-                    vid_out = gr.Video(label="Protected Video")
-                    vid_btn = gr.Button("Process Video", variant="primary")
-                    vid_btn.click(process_video, [vid_in, sensitivity, blur_type, blur_intensity], [vid_out, gr.Markdown()])
-
-                with gr.Tab("Webcam"):
-                    webcam = gr.Image(sources=["webcam"], streaming=True, label="Live Feed", height=520)
-                    webcam_out = gr.Image(label="Protected Live Feed", height=520)
-                    webcam.stream(process_image, [webcam, sensitivity, blur_type, blur_intensity], webcam_out)
-
-    add_btn.click(add_person, [pid, pname, photos], status)
-    gr.Markdown("---\n© 2025 – Privacy-first face redaction · Recognition works offline if deps missing")
-
-demo.launch()
+                # ========== DETECTION MODE ==========
+                with gr.TabItem("🔍 Detection Mode"):
+                    gr.Markdown("### Just detect faces - no modifications")
+                    
+                    with gr.Tabs():
+                        with gr.TabItem("📷 Image"):
+                            with gr.Row():
+                                det_img_in = gr.Image(
+                                    sources=["upload", "clipboard"], 
+                                    type="numpy", 
+                                    label="Input",
+                                    height=400
+                                )
+                                with gr.Column():
+                                    det_img_out = gr.Image(
+                                        type="numpy", 
+                                        label="Detection Result",
+                                        height=350
+                                    )
+                                    det_img_status = gr.Markdown("_Upload an image_")
+                            
+                            with gr.Row():
+                                det_img_btn = gr.Button("Detect Faces", variant="primary", scale=3)
+                                gr.ClearButton([det_img_in, det_img_out, det_img_status], scale=1)
+                        
+                        with gr.TabItem("🎥 Video"):
+                            with gr.Row():
+                                det_vid_in = gr.File(
+                                    file_types=[".mp4", ".mov", ".avi"], 
+                                    label="Input Video"
+                                )
+                                with gr.Column():
+                                    det_vid_out = gr.Video(
+                                        label="Annotated Video",
+                                        height=400
+                                    )
+                                    det_vid_status = gr.Markdown("_Upload a video_")
+                            with gr.Row():
+                                det_vid_btn = gr.Button("Analyze Video", variant="primary", scale=3)
+                                gr.ClearButton([det_vid_in, det_vid_out, det_vid_status], scale=1)
+                        
+                        with gr.TabItem("📹 Webcam"):
+                            with gr.Row():
+                                det_web_in = gr.Image(
+                                    sources=["webcam"], 
+                                    type="numpy", 
+                                    streaming=True, 
+                                    label="Live Feed",
+                                    height=400
+                                )
+                                det_web_out = gr.Image(
+                                    type="numpy", 
+                                    label="Detection",
+                                    height=400
+                                )
+
+                # ========== PRIVACY MODE ==========
+                with gr.TabItem("🔒 Privacy Mode"):
+                    gr.Markdown("### Blur all faces for complete privacy")
+                    
+                    with gr.Tabs():
+                        with gr.TabItem("📷 Image"):
+                            with gr.Row():
+                                priv_img_in = gr.Image(
+                                    sources=["upload", "clipboard"], 
+                                    type="numpy", 
+                                    label="Input",
+                                    height=400
+                                )
+                                priv_img_out = gr.Image(
+                                    type="numpy", 
+                                    label="Protected Image",
+                                    height=400
+                                )
+                            with gr.Row():
+                                priv_img_btn = gr.Button("Apply Privacy Blur", variant="primary", scale=3)
+                                gr.ClearButton([priv_img_in, priv_img_out], scale=1)
+                        
+                        with gr.TabItem("🎥 Video"):
+                            with gr.Row():
+                                priv_vid_in = gr.File(
+                                    file_types=[".mp4", ".mov", ".avi"], 
+                                    label="Input Video"
+                                )
+                                with gr.Column():
+                                    priv_vid_out = gr.Video(
+                                        label="Protected Video",
+                                        height=400
+                                    )
+                                    priv_vid_status = gr.Markdown("")
+                            with gr.Row():
+                                priv_vid_btn = gr.Button("Process Video", variant="primary", scale=3)
+                                gr.ClearButton([priv_vid_in, priv_vid_out, priv_vid_status], scale=1)
+                        
+                        with gr.TabItem("📹 Webcam"):
+                            with gr.Row():
+                                priv_web_in = gr.Image(
+                                    sources=["webcam"], 
+                                    type="numpy", 
+                                    streaming=True, 
+                                    label="Live Feed",
+                                    height=400
+                                )
+                                priv_web_out = gr.Image(
+                                    type="numpy", 
+                                    label="Protected Feed",
+                                    height=400
+                                )
+
+                # ========== SMART PRIVACY MODE ==========
+                with gr.TabItem("🎯 Smart Privacy Mode"):
+                    gr.Markdown("### **The Innovation:** Blur faces while preserving identity information")
+                    gr.Markdown("*All faces are blurred but labeled with their identity*")
+                    
+                    with gr.Tabs():
+                        with gr.TabItem("📷 Image"):
+                            with gr.Row():
+                                smart_img_in = gr.Image(
+                                    sources=["upload", "clipboard"], 
+                                    type="numpy", 
+                                    label="Input",
+                                    height=400
+                                )
+                                with gr.Column():
+                                    smart_img_out = gr.Image(
+                                        type="numpy", 
+                                        label="Smart Privacy Result",
+                                        height=350
+                                    )
+                                    smart_img_status = gr.Markdown("_Upload an image_")
+                            
+                            with gr.Row():
+                                smart_img_btn = gr.Button("🎯 Apply Smart Privacy", variant="primary", scale=3)
+                                gr.ClearButton([smart_img_in, smart_img_out, smart_img_status], scale=1)
+                        
+                        with gr.TabItem("🎥 Video"):
+                            with gr.Row():
+                                smart_vid_in = gr.File(
+                                    file_types=[".mp4", ".mov", ".avi"], 
+                                    label="Input Video"
+                                )
+                                with gr.Column():
+                                    smart_vid_out = gr.Video(
+                                        label="Smart Privacy Video",
+                                        height=400
+                                    )
+                                    smart_vid_status = gr.Markdown("")
+                            with gr.Row():
+                                smart_vid_btn = gr.Button("🎯 Process with Smart Privacy", variant="primary", scale=3)
+                                gr.ClearButton([smart_vid_in, smart_vid_out, smart_vid_status], scale=1)
+                        
+                        with gr.TabItem("📹 Webcam"):
+                            with gr.Row():
+                                smart_web_in = gr.Image(
+                                    sources=["webcam"], 
+                                    type="numpy", 
+                                    streaming=True, 
+                                    label="Live Feed",
+                                    height=400
+                                )
+                                with gr.Column():
+                                    smart_web_out = gr.Image(
+                                        type="numpy", 
+                                        label="Smart Privacy Feed",
+                                        height=400
+                                    )
+                                    smart_web_status = gr.Markdown("")
+
+    # ========== EVENT HANDLERS ==========
+    
+    # Detection Mode
+    det_img_btn.click(
+        detect_faces_image,
+        inputs=[det_img_in, detection_sensitivity],
+        outputs=[det_img_out, det_img_status]
+    )
+    det_vid_btn.click(
+        detect_faces_video,
+        inputs=[det_vid_in, detection_sensitivity],
+        outputs=[det_vid_out, det_vid_status]
+    )
+    det_web_in.stream(
+        detect_faces_webcam,
+        inputs=[det_web_in, detection_sensitivity],
+        outputs=det_web_out
+    )
+    
+    # Privacy Mode
+    priv_img_btn.click(
+        process_privacy_image,
+        inputs=[priv_img_in, blur_type, blur_amount, blur_size, detection_sensitivity],
+        outputs=priv_img_out
+    )
+    priv_vid_btn.click(
+        process_privacy_video,
+        inputs=[priv_vid_in, blur_type, blur_amount, blur_size, detection_sensitivity],
+        outputs=[priv_vid_out, priv_vid_status]
+    )
+    priv_web_in.stream(
+        process_privacy_webcam,
+        inputs=[priv_web_in, blur_type, blur_amount, blur_size, detection_sensitivity],
+        outputs=priv_web_out
+    )
+    
+    # Smart Privacy Mode
+    smart_img_btn.click(
+        process_smart_image,
+        inputs=[smart_img_in, blur_type, blur_amount, blur_size, detection_sensitivity],
+        outputs=[smart_img_out, smart_img_status]
+    )
+    smart_vid_btn.click(
+        process_smart_video,
+        inputs=[smart_vid_in, blur_type, blur_amount, blur_size, detection_sensitivity],
+        outputs=[smart_vid_out, smart_vid_status]
+    )
+    smart_web_in.stream(
+        process_smart_webcam,
+        inputs=[smart_web_in, blur_type, blur_amount, blur_size, detection_sensitivity],
+        outputs=[smart_web_out, smart_web_status]
+    )
+
+# ====================================================
+# MAIN ENTRY POINT
+# ====================================================
+if __name__ == "__main__":
+    logger.info("🚀 Initializing Unified Face Tool...")
+    try:
+        # Initialize detector
+        get_global_detector()
+        
+        # Initialize face database (if available)
+        if DEEPFACE_AVAILABLE and CHROMADB_AVAILABLE:
+            get_face_database()
+        
+        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")