opuv2

app.py

@@ -1,16 +1,10 @@
-"""
-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 dataclasses import dataclass
 from typing import Any, Dict, List, Tuple, Optional
 from pathlib import Path
 
@@ -20,1051 +14,486 @@ import numpy as np
 import gradio as gr
 from ultralytics import YOLO
 
-# --- Face Recognition Libraries (Optional) ---
+# --- Face Recognition Libraries (Optional / Fallback) ---
 try:
     from deepface import DeepFace
     DEEPFACE_AVAILABLE = True
 except ImportError:
     DEEPFACE_AVAILABLE = False
-    logging.warning("⚠️ DeepFace not installed - recognition features will fallback to 'Unknown'")
+    logging.warning("⚠️ DeepFace not installed - Recognition will be disabled (Fallback Mode).")
 
 try:
     import chromadb
     CHROMADB_AVAILABLE = True
 except ImportError:
     CHROMADB_AVAILABLE = False
-    logging.warning("⚠️ ChromaDB not installed - recognition features will fallback to 'Unknown'")
+    logging.warning("⚠️ ChromaDB not installed - Database features disabled.")
 
 # --- Configure Logging ---
 logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
 logger = logging.getLogger(__name__)
 
 # ====================================================
-# TEMPORARY FILE CLEANUP
+# 1. CONFIGURATION & UTILITIES
 # ====================================================
+
+# --- HARDCODED DEFAULTS (EXPERT MODE) ---
+CONFIDENCE_THRESHOLD = 0.3   # High Sensitivity
+TARGET_MOSAIC_GRID = 12      # Adaptive Grid (12 blocks across face)
+COVERAGE_SCALE = 1.1         # 110% Coverage (Margin)
+
 TEMP_FILES = []
 
 def cleanup_temp_files():
-    """Clean up any temporary files created during the session on exit."""
+    """Clean up temporary video files 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}")
+        except Exception:
+            pass
 
 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
 
 # ====================================================
-# SENSITIVITY MAPPING
-# ====================================================
-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:
-    """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
-
+# 2. THE DATABASE LAYER (Backend Only - No UI)
 # ====================================================
-# 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 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)
+class FaceDatabase:
+    """
+    Handles loading known faces from the 'known_faces' folder.
+    Runs automatically on startup.
+    """
+    def __init__(self, db_path="./chroma_db", faces_dir="known_faces"):
+        self.faces_dir = Path(faces_dir)
+        self.client = None
+        self.collection = None
+        self.is_active = False
         
-        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
-        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)
-
-# ====================================================
-# FACE DATABASE (Simplified, no UI)
-# ====================================================
-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
+        if not DEEPFACE_AVAILABLE or not CHROMADB_AVAILABLE:
+            logger.warning("❌ Database unavailable (Missing dependencies)")
             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"}
             )
+            self.is_active = True
             
-            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()
+            # Auto-index on startup
+            if self.faces_dir.exists():
+                self._scan_and_index()
             else:
-                self.known_faces_dir.mkdir(parents=True, exist_ok=True)
+                self.faces_dir.mkdir(parents=True, exist_ok=True)
+                logger.info(f"📁 Created {faces_dir} folder. Add images here!")
                 
         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."""
+            logger.error(f"❌ DB Init Error: {e}")
+            self.is_active = False
+
+    def _get_hash(self, img_path: Path) -> str:
         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
+
+    def _scan_and_index(self):
+        """Scans folders and adds new images to ChromaDB."""
+        logger.info("🔄 Scanning 'known_faces' folder...")
+        count = 0
+        for person_dir in self.faces_dir.iterdir():
+            if not person_dir.is_dir(): continue
             
-            person_id, person_name = parts
-            person_name = person_name.replace('_', ' ').title()
+            # Folder format expectation: "001_John_Doe"
+            parts = person_dir.name.split('_', 1)
+            if len(parts) < 2: 
+                # Fallback for folders like "John"
+                p_id = "000"
+                p_name = person_dir.name
+            else:
+                p_id, p_name = parts[0], parts[1].replace('_', ' ')
             
-            image_files = list(person_dir.glob("*.jpg")) + \
-                         list(person_dir.glob("*.png")) + \
-                         list(person_dir.glob("*.jpeg"))
+            images = list(person_dir.glob("*.jpg")) + list(person_dir.glob("*.png")) + list(person_dir.glob("*.webp"))
             
-            for img_path in image_files:
+            for img_path in images:
                 try:
-                    img_hash = self._get_image_hash(img_path)
-                    existing = self.collection.get(ids=[img_hash], include=[])
-                    
-                    if existing['ids']:
+                    img_hash = self._get_hash(img_path)
+                    # Check if already indexed
+                    if self.collection.get(ids=[img_hash])['ids']:
                         continue
-                    
-                    embedding_obj = DeepFace.represent(
-                        img_path=str(img_path),
-                        model_name=self.model_name,
+                        
+                    # Generate Embedding
+                    embedding_objs = DeepFace.represent(
+                        img_path=str(img_path), 
+                        model_name="Facenet512", 
                         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})")
-                    
+                    if embedding_objs:
+                        embedding = embedding_objs[0]["embedding"]
+                        self.collection.add(
+                            ids=[img_hash],
+                            embeddings=[embedding],
+                            metadatas=[{"id": p_id, "name": p_name, "file": img_path.name}]
+                        )
+                        count += 1
+                        logger.info(f"✅ Indexed: {p_name}")
                 except Exception as e:
-                    logger.error(f"❌ Failed to index {img_path}: {e}")
+                    logger.error(f"⚠️ Failed to index {img_path.name}: {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"}
+        if count > 0: 
+            logger.info(f"📥 Added {count} new faces to database.")
+        else:
+            logger.info("ℹ️ Database is up to date.")
+
+    def recognize(self, face_img: np.ndarray) -> Dict[str, Any]:
+        """Returns {'match': bool, 'name': str, 'id': str, 'color': tuple}"""
+        # Default response (Unknown / Red)
+        default = {"match": False, "name": "Unknown", "id": "Unknown", "color": (255, 0, 0)} 
         
+        if not self.is_active or self.collection is None or self.collection.count() == 0:
+            return default
+
         try:
-            temp_path = "temp_face.jpg"
-            cv2.imwrite(temp_path, cv2.cvtColor(face_image, cv2.COLOR_RGB2BGR))
+            # Create temp file for DeepFace (it prefers paths)
+            temp_path = "temp_query.jpg"
+            cv2.imwrite(temp_path, cv2.cvtColor(face_img, cv2.COLOR_RGB2BGR))
             
-            embedding_obj = DeepFace.represent(
+            embedding_objs = DeepFace.represent(
                 img_path=temp_path,
-                model_name=self.model_name,
+                model_name="Facenet512",
                 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"]
-            
+            if os.path.exists(temp_path): os.remove(temp_path)
+
+            if not embedding_objs: return default
+
+            query_embed = embedding_objs[0]["embedding"]
             results = self.collection.query(
-                query_embeddings=[face_embedding],
-                n_results=1,
-                include=["metadatas", "distances"]
+                query_embeddings=[query_embed],
+                n_results=1
             )
-            
-            if not results['ids'][0]:
-                return {"match": False, "person_id": "unknown", "name": "Unknown"}
-            
+
+            if not results['ids'][0]: return default
+
             distance = results['distances'][0][0]
             metadata = results['metadatas'][0][0]
-            
-            if distance < threshold:
+
+            # Threshold: Lower is stricter. 0.45 is a good balance for Facenet512
+            if distance < 0.45:
                 return {
                     "match": True,
-                    "person_id": metadata['person_id'],
-                    "name": metadata['person_name']
+                    "name": metadata['name'],
+                    "id": metadata['id'],
+                    "color": (0, 255, 0) # Green for match
                 }
-            
-            return {"match": False, "person_id": "unknown", "name": "Unknown"}
-                
+            return default
+
         except Exception as e:
-            logger.error(f"❌ Recognition error: {e}")
-            return {"match": False, "person_id": "unknown", "name": "Unknown"}
+            logger.error(f"Recognition Error: {e}")
+            return default
 
-# Global database instance
-FACE_DB: Optional[SimpleFaceDatabase] = None
+    def get_stats(self):
+        if self.is_active and self.collection:
+            return f"✅ Active | {self.collection.count()} Faces Indexed"
+        return "❌ Offline (Check dependencies or 'known_faces' folder)"
 
-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
+# Singleton DB
+FACE_DB = FaceDatabase()
 
 # ====================================================
-# UNIFIED YOLO DETECTOR
+# 3. THE UNIFIED DETECTOR (YOLO)
 # ====================================================
-class UnifiedYOLODetector:
-    """Unified face detector using YOLOv8-Face model."""
-    def __init__(self, config: DetectionConfig):
+class Detector:
+    def __init__(self):
+        logger.info("📦 Loading YOLOv8-Face...")
         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.")
+            self.model = YOLO("yolov8n-face.pt")
+            logger.info("✅ Model Loaded.")
         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)
+            logger.error(f"❌ Model Load Failed: {e}")
+            raise e
+    
+    def detect(self, image: np.ndarray):
+        # Uses Hardcoded High Sensitivity
+        results = self.model(image, conf=CONFIDENCE_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])
-                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
+                faces.append({
+                    "box": (x1, y1, x2-x1, y2-y1),
+                    "conf": float(box.conf[0])
+                })
+        return faces
 
-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
+GLOBAL_DETECTOR = Detector()
 
 # ====================================================
-# SMART PRIVACY APPLICATION
+# 4. CORE LOGIC
 # ====================================================
-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 apply_blur(image, x, y, w, h):
+    """
+    ADAPTIVE BLUR: Solves the 'Big Image' problem.
+    Ensures face is always reduced to TARGET_MOSAIC_GRID blocks.
+    """
+    h_img, w_img = image.shape[:2]
+    
+    # --- COVERAGE AREA SCALE ---
+    # We add padding based on COVERAGE_SCALE
+    pad_w = int(w * (COVERAGE_SCALE - 1.0) / 2)
+    pad_h = int(h * (COVERAGE_SCALE - 1.0) / 2)
+    
+    x = max(0, x - pad_w)
+    y = max(0, y - pad_h)
+    w = min(w_img - x, w + (2 * pad_w))
+    h = min(h_img - y, h + (2 * pad_h))
+    
+    roi = image[y:y+h, x:x+w]
+    if roi.size == 0: return image
+    
+    h_roi, w_roi = roi.shape[:2]
+    
+    # --- ADAPTIVE GRID LOGIC ---
+    # We force the face down to a tiny grid (TARGET_MOSAIC_GRID)
+    aspect = w_roi / h_roi
+    target_w = TARGET_MOSAIC_GRID
+    target_h = int(TARGET_MOSAIC_GRID / aspect)
+    
+    target_w = max(2, target_w)
+    target_h = max(2, target_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"
+    # Downscale (Destroy Detail)
+    small = cv2.resize(roi, (target_w, target_h), interpolation=cv2.INTER_LINEAR)
+    # Upscale (Pixelate)
+    pixelated = cv2.resize(small, (w_roi, h_roi), interpolation=cv2.INTER_NEAREST)
+    
+    image[y:y+h, x:x+w] = pixelated
+    return image
+
+def draw_label(image, x, y, w, text, color, on_blur=False):
+    """Annotation step: Draws text."""
+    font = cv2.FONT_HERSHEY_SIMPLEX
+    scale = 0.6
+    thickness = 2
+    (tw, th), _ = cv2.getTextSize(text, font, scale, thickness)
+    
+    if on_blur:
+        center_x = x + (w // 2) - (tw // 2)
+        center_y = y + (w // 2)
+        cv2.rectangle(image, (center_x - 5, center_y - th - 5), (center_x + tw + 5, center_y + 5), color, -1)
+        cv2.putText(image, text, (center_x, center_y), font, scale, (255, 255, 255), thickness)
+    else:
+        cv2.rectangle(image, (x, y - th - 10), (x + tw + 10, y), color, -1)
+        cv2.putText(image, text, (x + 5, y - 5), font, scale, (255, 255, 255), thickness)
+
+def process_frame(image, mode):
+    """
+    THE MASTER FUNCTION.
+    Returns: (processed_image, log_string)
+    """
+    if image is None: return None, "No Image"
+    
+    # 1. Detection
+    faces = GLOBAL_DETECTOR.detect(image)
+    processed_img = image.copy()
+    log_entries = []
+    
+    for i, face in enumerate(faces):
+        x, y, w, h = face['box']
         
-        # 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)
+        # 2. Analysis
+        identity = {"name": "", "color": (0, 255, 0)}
         
-        # 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)
+        if mode in ["data", "smart"]:
+            # Crop and Check DB
+            face_crop = image[y:y+h, x:x+w]
+            if face_crop.size > 0:
+                res = FACE_DB.recognize(face_crop)
+                
+                if res['match']:
+                    label_text = f"ID: {res['id']} ({res['name']})"
+                    log_entries.append(f"✅ Face #{i+1}: MATCH - {res['name']} (ID: {res['id']})")
+                else:
+                    label_text = "Unknown"
+                    log_entries.append(f"⚠️ Face #{i+1}: UNKNOWN")
+                    
+                identity = {"name": label_text, "color": res['color']}
+        else:
+             log_entries.append(f"🔒 Face #{i+1}: Anonymized")
+
+        # 3. Modification
+        if mode == "privacy":
+            processed_img = apply_blur(processed_img, x, y, w, h)
             
-            # 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
+        elif mode == "data":
+            cv2.rectangle(processed_img, (x, y), (x+w, y+h), identity['color'], 2)
+            draw_label(processed_img, x, y, w, identity['name'], identity['color'], on_blur=False)
             
-            # Draw background rectangle
-            cv2.rectangle(writable_image, 
-                         (x1, label_y - text_height - 5), 
-                         (x1 + text_width + 10, label_y + 5), 
-                         bg_color, -1)
+        elif mode == "smart":
+            processed_img = apply_blur(processed_img, x, y, w, h)
+            draw_label(processed_img, x, y, w, identity['name'], identity['color'], on_blur=True)
             
-            # 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
+    # Create Log String
+    if not log_entries:
+        final_log = "No faces detected."
+    else:
+        final_log = "--- Detection Report ---\n" + "\n".join(log_entries)
 
-    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
+    return processed_img, final_log
 
 # ====================================================
-# GRADIO HANDLER FUNCTIONS
+# 5. VIDEO PROCESSING HELPERS
 # ====================================================
-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))
+def process_video_general(video_path, mode, progress=gr.Progress()):
+    """Generic video processor."""
+    if not video_path: return None
+    
+    cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened(): return None
 
-        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()
+    fps = int(cap.get(cv2.CAP_PROP_FPS))
+    width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    total = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    
+    out_path = create_temp_file()
+    fourcc = cv2.VideoWriter_fourcc(*'avc1')
+    out = cv2.VideoWriter(out_path, fourcc, fps, (width, height))
+    if not out.isOpened():
+         out = cv2.VideoWriter(out_path, cv2.VideoWriter_fourcc(*'mp4v'), fps, (width, height))
+    
+    cnt = 0
+    while cap.isOpened():
+        ret, frame = cap.read()
+        if not ret: break
         
-        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.**"
+        # Process using the Master Function (Ignore log for video)
+        res_frame, _ = process_frame(frame, mode)
         
-        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)
+        out.write(res_frame)
+        cnt += 1
+        if total > 0 and cnt % 10 == 0: 
+            progress(cnt/total, desc=f"Processing Frame {cnt}/{total}")
         
-        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}"
+    cap.release()
+    out.release()
+    return out_path
 
-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."
+# ====================================================
+# 6. GRADIO INTERFACE
+# ====================================================
 
-        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))
+with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue"), title="Smart Redaction Demo") as demo:
+    
+    gr.Markdown("# 🛡️ Smart Redaction System")
+    gr.Markdown("### From Raw Privacy to Intelligent Security")
+    
+    # Unified Config Info Row
+    with gr.Row():
+        gr.Markdown(f"**System Status:** {FACE_DB.get_stats()}")
+        gr.Markdown(f"**Config:** Adaptive Pixelate | High Sensitivity | 110% Coverage")
 
-        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 = []
+    with gr.Tabs():
         
-        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}")
+        # --- TAB 1: RAW PRIVACY ---
+        with gr.TabItem("1️⃣ Raw Privacy (Baseline)"):
+            gr.Markdown("### 🔒 Total Anonymization")
+            gr.Markdown("*Scenario: GDPR Compliance. Everyone is hidden. No data is extracted.*")
             
-            # 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)
+            with gr.Tabs():
+                with gr.TabItem("Image"):
+                    p_img_in = gr.Image(label="Input", type="numpy", height=400)
+                    p_img_out = gr.Image(label="Anonymized Output", height=400)
+                    p_btn = gr.Button("Apply Privacy", variant="primary")
                     
-                    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
+                with gr.TabItem("Video"):
+                    p_vid_in = gr.Video(label="Input Video")
+                    p_vid_out = gr.Video(label="Anonymized Output")
+                    p_vid_btn = gr.Button("Process Video", variant="primary")
                     
-                    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)
+                with gr.TabItem("Webcam"):
+                    p_web_in = gr.Image(sources=["webcam"], streaming=True, type="numpy")
+                    p_web_out = gr.Image(label="Live Privacy Feed")
+
+        # --- TAB 2: THE DATA LAYER ---
+        with gr.TabItem("2️⃣ The Data Layer (Security)"):
+            gr.Markdown("### 🔍 Recognition & Intelligence")
+            gr.Markdown("*Scenario: Security Control Room. We identify Known vs Unknown. No Privacy.*")
             
-            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
-
-# ====================================================
-# GRADIO UI
-# ====================================================
-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():
-        # ========== 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():
-                # ========== DETECTION MODE ==========
-                with gr.TabItem("🔍 Detection Mode"):
-                    gr.Markdown("### Just detect faces - no modifications")
+                with gr.TabItem("Image"):
+                    with gr.Row():
+                        d_img_in = gr.Image(label="Input", type="numpy", height=400)
+                        with gr.Column():
+                            d_img_out = gr.Image(label="Data Output", height=400)
+                            d_log_out = gr.Textbox(label="Detection Log", lines=4)
+                    d_btn = gr.Button("Analyze Data", variant="primary")
                     
-                    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.TabItem("Video"):
+                    d_vid_in = gr.Video(label="Input Video")
+                    d_vid_out = gr.Video(label="Data Output")
+                    d_vid_btn = gr.Button("Analyze Video", variant="primary")
                     
-                    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.TabItem("Webcam"):
+                    d_web_in = gr.Image(sources=["webcam"], streaming=True, type="numpy")
+                    d_web_out = gr.Image(label="Live Data Feed")
+
+        # --- TAB 3: SMART REDACTION ---
+        with gr.TabItem("3️⃣ Smart Redaction (Combined)"):
+            gr.Markdown("### 🛡️ Intelligent Privacy")
+            gr.Markdown("*Scenario: The Solution. Faces are blurred for privacy, but Identities are overlaid for security.*")
+            
+            with gr.Tabs():
+                with gr.TabItem("Image"):
+                    with gr.Row():
+                        s_img_in = gr.Image(label="Input", type="numpy", height=400)
+                        with gr.Column():
+                            s_img_out = gr.Image(label="Smart Redaction Output", height=400)
+                            s_log_out = gr.Textbox(label="Detection Log", lines=4)
+                    s_btn = gr.Button("Apply Smart Redaction", variant="primary")
                     
-                    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("")
+                with gr.TabItem("Video"):
+                    s_vid_in = gr.Video(label="Input Video")
+                    s_vid_out = gr.Video(label="Smart Redaction Output")
+                    s_vid_btn = gr.Button("Process Smart Video", variant="primary")
+                    
+                with gr.TabItem("Webcam"):
+                    s_web_in = gr.Image(sources=["webcam"], streaming=True, type="numpy")
+                    s_web_out = gr.Image(label="Live Smart Feed")
 
-    # ========== 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
-    )
+    # =========================================
+    # EVENT HANDLERS 
+    # =========================================
     
-    # 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]
-    )
+    # Tab 1: Privacy (Mode="privacy")
+    # Note: We use [0] index for streaming/image to just get the image, ignoring log
+    p_btn.click(lambda img: process_frame(img, "privacy")[0], inputs=[p_img_in], outputs=p_img_out)
+    p_vid_btn.click(lambda vid: process_video_general(vid, "privacy"), inputs=[p_vid_in], outputs=p_vid_out)
+    p_web_in.stream(lambda img: process_frame(img, "privacy")[0], inputs=[p_web_in], outputs=p_web_out)
+
+    # Tab 2: Data (Mode="data")
+    # Image returns [image, log]
+    d_btn.click(lambda img: process_frame(img, "data"), inputs=[d_img_in], outputs=[d_img_out, d_log_out])
+    d_vid_btn.click(lambda vid: process_video_general(vid, "data"), inputs=[d_vid_in], outputs=d_vid_out)
+    d_web_in.stream(lambda img: process_frame(img, "data")[0], inputs=[d_web_in], outputs=d_web_out)
+
+    # Tab 3: Smart (Mode="smart")
+    # Image returns [image, log]
+    s_btn.click(lambda img: process_frame(img, "smart"), inputs=[s_img_in], outputs=[s_img_out, s_log_out])
+    s_vid_btn.click(lambda vid: process_video_general(vid, "smart"), inputs=[s_vid_in], outputs=s_vid_out)
+    s_web_in.stream(lambda img: process_frame(img, "smart")[0], inputs=[s_web_in], outputs=s_web_out)
 
-# ====================================================
-# 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...")
+        if GLOBAL_DETECTOR:
+            logger.info("✅ System Ready. Launching...")
         demo.launch()
     except Exception as e:
-        logger.error(f"❌ Startup failed: {e}")
-        logger.info("💡 Make sure 'yolov8n-face.pt' is available")
+        logger.error(f"Startup Failed: {e}")