3pro

app.py

@@ -1,16 +1,12 @@
-"""
-Face Recognition Tool (YOLO + DeepFace + ChromaDB)
-"""
-
 # --- Standard Libraries ---
 import logging
 import atexit
 import tempfile
 import os
+import hashlib
 from dataclasses import dataclass
 from typing import Any, Dict, List, Tuple, Optional
 from pathlib import Path
-import hashlib
 
 # --- Computer Vision & UI Libraries ---
 import cv2
@@ -18,884 +14,507 @@ import numpy as np
 import gradio as gr
 from ultralytics import YOLO
 
-# --- HuggingFace Hub API ---
-try:
-    from huggingface_hub import HfApi
-    HF_HUB_AVAILABLE = True
-except ImportError:
-    HF_HUB_AVAILABLE = False
-    logging.warning("⚠️ huggingface_hub not installed - auto-commit disabled")
-
-# --- Face Recognition Libraries ---
+# --- Face Recognition Libraries (Optional / Fallback) ---
 try:
     from deepface import DeepFace
     DEEPFACE_AVAILABLE = True
 except ImportError:
     DEEPFACE_AVAILABLE = False
-    logging.warning("⚠️ DeepFace not installed")
+    logging.warning("⚠️ DeepFace not installed - Recognition will be disabled (Fallback Mode).")
 
 try:
     import chromadb
-    from chromadb.config import Settings
     CHROMADB_AVAILABLE = True
 except ImportError:
     CHROMADB_AVAILABLE = False
-    logging.warning("⚠️ ChromaDB not installed")
+    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
 # ====================================================
+
 TEMP_FILES = []
 
 def cleanup_temp_files():
-    """Clean up temporary files 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: {f}")
-        except Exception as e:
-            logger.warning(f"⚠️ Failed to delete {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
 
 # ====================================================
-# SCALABLE FACE DATABASE (ChromaDB)
+# 2. THE DATABASE LAYER (Backend Only - No UI)
 # ====================================================
-class ScalableFaceDatabase:
-    """Production-ready face recognition system using ChromaDB."""
-    
-    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
-        
-        # HuggingFace Hub API for auto-commit
-        self.hf_token = os.getenv("HF_TOKEN")
-        self.space_id = os.getenv("SPACE_ID")
-        
-        if HF_HUB_AVAILABLE and self.hf_token and self.space_id:
-            self.hf_api = HfApi()
-            logger.info(f"✅ Auto-commit enabled for Space: {self.space_id}")
-        else:
-            self.hf_api = None
-            if not self.hf_token:
-                logger.warning("⚠️ HF_TOKEN not set - auto-commit disabled")
-            if not self.space_id:
-                logger.warning("⚠️ SPACE_ID not set - auto-commit disabled")
-        
-        if not CHROMADB_AVAILABLE:
-            logger.error("❌ ChromaDB not available")
-            self.client = None
-            self.collection = None
+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
+        
+        if not DEEPFACE_AVAILABLE or not CHROMADB_AVAILABLE:
+            logger.warning("❌ Database unavailable (Missing dependencies)")
             return
-        
-        # Initialize ChromaDB
-        logger.info("🔧 Initializing ChromaDB...")
+
         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:
-                logger.info(f"📁 Creating {self.known_faces_dir} directory...")
-                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"❌ ChromaDB initialization failed: {e}")
-            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
-            
-            person_id, person_name = parts
-            person_name = person_name.replace('_', ' ').title()
+
+    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
+            
+            # 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")) + \
-                         list(person_dir.glob("*.webp")) + \
-                         list(person_dir.glob("*.avif")) + \
-                         list(person_dir.glob("*.bmp")) + \
-                         list(person_dir.glob("*.tiff"))
+            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
-                    
-                    if not DEEPFACE_AVAILABLE:
-                        logger.warning("⚠️ DeepFace not available, skipping indexing")
-                        return
-                    
-                    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}) - {img_path.name}")
-                    
+                    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)")
-            logger.info(f"📊 Total faces in database: {self.collection.count()}")
+        if count > 0: 
+            logger.info(f"📥 Added {count} new faces to database.")
         else:
-            logger.info("ℹ️ No new faces to index")
-    
-    def add_person(self, person_id: str, person_name: str, face_image: np.ndarray) -> Tuple[bool, str]:
-        """Add a new person to the database and commit to git."""
-        if not CHROMADB_AVAILABLE or self.collection is None:
-            return False, "❌ ChromaDB not available"
-        
-        if not DEEPFACE_AVAILABLE:
-            return False, "❌ DeepFace not available"
-        
-        try:
-            folder_name = f"{person_id}_{person_name.lower().replace(' ', '_')}"
-            person_dir = self.known_faces_dir / folder_name
-            person_dir.mkdir(parents=True, exist_ok=True)
-            
-            # ✅ NEW: Auto-increment filename for multiple images
-            existing_images = list(person_dir.glob(f"{person_id}_*.jpg"))
-            next_num = len(existing_images) + 1
-            img_filename = f"{person_id}_{next_num}.jpg"
-            img_path = person_dir / img_filename
-            
-            cv2.imwrite(str(img_path), cv2.cvtColor(face_image, cv2.COLOR_RGB2BGR))
-            logger.info(f"💾 Saved image: {img_path}")
-            
-            commit_success = False
-            if self.hf_api and self.hf_token and self.space_id:
-                try:
-                    self.hf_api.upload_file(
-                        path_or_fileobj=str(img_path),
-                        path_in_repo=f"known_faces/{folder_name}/{img_filename}",
-                        repo_id=self.space_id,
-                        repo_type="space",
-                        token=self.hf_token,
-                        commit_message=f"Add image #{next_num} for {person_name} (ID: {person_id})"
-                    )
-                    logger.info(f"✅ Committed to git!")
-                    commit_success = True
-                except Exception as e:
-                    logger.warning(f"⚠️ Git commit failed: {e}")
-            
-            embedding_obj = DeepFace.represent(
-                img_path=str(img_path),
-                model_name=self.model_name,
-                enforce_detection=True
-            )
-            
-            if not embedding_obj:
-                return False, "❌ No face detected in image"
-            
-            embedding = embedding_obj[0]["embedding"]
-            img_hash = self._get_image_hash(img_path)
-            
-            self.collection.add(
-                embeddings=[embedding],
-                documents=[str(img_path)],
-                metadatas=[{
-                    "person_id": person_id,
-                    "person_name": person_name,
-                    "image_file": img_filename
-                }],
-                ids=[img_hash]
-            )
-            
-            success_msg = f"✅ Added image #{next_num} for {person_name} (ID: {person_id})\n"
-            if commit_success:
-                success_msg += "🔒 Committed to git - PERMANENT!"
-            else:
-                success_msg += "⚠️ Saved locally only"
-            
-            return True, success_msg
-            
-        except Exception as e:
-            logger.error(f"❌ Error: {e}")
-            return False, f"❌ Error: {str(e)}"
-    
-    def recognize_face(
-        self, 
-        face_image: np.ndarray, 
-        threshold: float = 0.45
-    ) -> Dict[str, Any]:
-        """Recognize a face using ChromaDB vector search."""
-        if not CHROMADB_AVAILABLE or self.collection is None:
-            return {"match": False, "person_id": "unknown", "name": "Unknown", "distance": 999}
-        
-        if not DEEPFACE_AVAILABLE:
-            return {"match": False, "person_id": "unknown", "name": "Unknown", "distance": 999}
-        
-        if self.collection.count() == 0:
-            return {"match": False, "person_id": "unknown", "name": "Unknown", "distance": 999}
+            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", "distance": 999}
-            
-            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", "distance": 999}
-            
+
+            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'],
-                    "distance": distance
+                    "name": metadata['name'],
+                    "id": metadata['id'],
+                    "color": (0, 255, 0) # Green for match
                 }
-            else:
-                return {"match": False, "person_id": "unknown", "name": "Unknown", "distance": distance}
-                
-        except Exception as e:
-            logger.error(f"❌ Recognition error: {e}")
-            return {"match": False, "person_id": "unknown", "name": "Unknown", "distance": 999}
-    
-    def get_all_persons(self) -> List[Dict[str, str]]:
-        """Get list of all registered persons."""
-        if not CHROMADB_AVAILABLE or self.collection is None:
-            return []
-        
-        try:
-            all_data = self.collection.get(include=["metadatas"])
-            
-            persons = {}
-            for metadata in all_data['metadatas']:
-                person_id = metadata['person_id']
-                if person_id not in persons:
-                    persons[person_id] = {
-                        "id": person_id,
-                        "name": metadata['person_name']
-                    }
-            
-            return list(persons.values())
-        except Exception as e:
-            logger.error(f"Error getting persons: {e}")
-            return []
-    
-    def delete_person(self, person_id: str) -> Tuple[bool, str]:
-        """Remove a person from the database."""
-        if not CHROMADB_AVAILABLE or self.collection is None:
-            return False, "❌ ChromaDB not available"
-        
-        try:
-            all_data = self.collection.get(include=["metadatas"])
-            ids_to_delete = [
-                all_data['ids'][i] 
-                for i, meta in enumerate(all_data['metadatas']) 
-                if meta['person_id'] == person_id
-            ]
-            
-            if ids_to_delete:
-                self.collection.delete(ids=ids_to_delete)
-                logger.info(f"🗑️ Deleted {len(ids_to_delete)} embeddings for ID: {person_id}")
-                return True, f"✅ Deleted person ID: {person_id}"
-            else:
-                return False, f"❌ Person ID not found: {person_id}"
-                
-        except Exception as e:
-            logger.error(f"Error deleting: {e}")
-            return False, f"❌ Error: {str(e)}"
+            return default
 
-# Global database instance
-FACE_DB: Optional[ScalableFaceDatabase] = None
+        except Exception as e:
+            logger.error(f"Recognition Error: {e}")
+            return default
 
-def get_face_database() -> ScalableFaceDatabase:
-    """Get or create the global face database."""
-    global FACE_DB
-    if FACE_DB is None:
-        FACE_DB = ScalableFaceDatabase()
-    return FACE_DB
+    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)"
 
-FIXED_CONFIDENCE = 0.55
+# Singleton DB
+FACE_DB = FaceDatabase()
 
 # ====================================================
-# YOLO DETECTOR
+# 3. THE UNIFIED DETECTOR (YOLO)
 # ====================================================
-@dataclass
-class DetectionConfig:
-    min_confidence: float = 0.6
-    model_path: str = "yolov8n-face.pt"
-
-class YOLOv8FaceDetector:
-    def __init__(self, config: DetectionConfig):
+class Detector:
+    def __init__(self):
+        logger.info("📦 Loading YOLOv8-Face...")
         try:
-            logger.info(f"📦 Loading YOLO model: {config.model_path}")
-            self.model = YOLO(config.model_path)
-            logger.info("✅ YOLO model loaded")
+            self.model = YOLO("yolov8n-face.pt")
+            logger.info("✅ Model Loaded.")
         except Exception as e:
-            logger.error(f"❌ YOLO loading failed: {e}")
-            raise RuntimeError(f"Cannot load YOLO model") from e
-
-    def detect_faces(
-        self, 
-        image: np.ndarray, 
-        conf_threshold: float, 
-        recognize: bool = False
-    ) -> Tuple[List[Dict[str, Any]], np.ndarray]:
-        """Detect and optionally recognize faces."""
-        results = self.model(image, conf=conf_threshold, verbose=False)
+            logger.error(f"❌ Model Load Failed: {e}")
+            raise e
+    
+    def detect(self, image: np.ndarray, conf: float = 0.5):
+        results = self.model(image, conf=conf, verbose=False)
         faces = []
-        annotated_image = image.copy()
-        
-        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
-                }
-                
-                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)
-                        
-                        color = (0, 255, 0) if recognition_result["match"] else (255, 0, 0)
-                        cv2.rectangle(annotated_image, (x1, y1), (x2, y2), color, 3)
-                        
-                        if recognition_result["match"]:
-                            label = f"{recognition_result['name']} ({recognition_result['person_id']})"
-                        else:
-                            label = "Unknown"
-                        
-                        (w, h), _ = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, 0.6, 2)
-                        cv2.rectangle(annotated_image, (x1, y1 - h - 10), (x1 + w, y1), color, -1)
-                        cv2.putText(annotated_image, label, (x1, y1 - 5),
-                                  cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 2)
-                else:
-                    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)
-                
-                faces.append(face_info)
-        
-        return faces, annotated_image
+                faces.append({
+                    "box": (x1, y1, x2-x1, y2-y1),
+                    "conf": float(box.conf[0])
+                })
+        return faces
 
-GLOBAL_DETECTOR: Optional[YOLOv8FaceDetector] = None
-
-def get_global_detector() -> YOLOv8FaceDetector:
-    global GLOBAL_DETECTOR
-    if GLOBAL_DETECTOR is None:
-        GLOBAL_DETECTOR = YOLOv8FaceDetector(DetectionConfig())
-    return GLOBAL_DETECTOR
+GLOBAL_DETECTOR = Detector()
 
 # ====================================================
-# GRADIO HANDLERS
+# 4. CORE LOGIC: THE "GHOST" PIPELINE
 # ====================================================
-def recognize_image(image):
-    """Recognize faces in image."""
-    if image is None:
-        return None, "⚠️ No image provided"
+
+def apply_blur(image, x, y, w, h, style="pixelate", intensity=20):
+    """Destructive step: Modifies pixels."""
+    # Expand blur slightly for safety (margin)
+    h_img, w_img = image.shape[:2]
+    margin = int(w * 0.1) # 10% margin
+    x = max(0, x - margin)
+    y = max(0, y - margin)
+    w = min(w_img - x, w + (2 * margin))
+    h = min(h_img - y, h + (2 * margin))
     
-    try:
-        detector = get_global_detector()
-        faces, annotated = detector.detect_faces(image, FIXED_CONFIDENCE, recognize=True)
-        
-        if faces:
-            known = sum(1 for f in faces if f.get("match", False))
-            unknown = len(faces) - known
-            
-            result = f"### 📊 Detection Results\n\n"
-            result += f"**Total Faces:** {len(faces)}\n\n"
-            result += f"- ✅ **Known:** {known}\n"
-            result += f"- ❓ **Unknown:** {unknown}\n\n"
-            
-            if known > 0:
-                result += "**Identified People:**\n"
-                for i, f in enumerate(faces, 1):
-                    if f.get("match"):
-                        result += f"{i}. {f['name']} (ID: {f['person_id']})\n"
-        else:
-            result = "❌ **No faces detected**"
-        
-        return annotated, result
-    except Exception as e:
-        logger.error(f"Error: {e}")
-        return image, f"❌ Error: {str(e)}"
+    roi = image[y:y+h, x:x+w]
+    if roi.size == 0: return image
+    
+    if style == "pixelate":
+        # Divide by intensity to shrink, then scale back up
+        h_roi, w_roi = roi.shape[:2]
+        k = max(2, int(100 - intensity) // 2) # Inverse logic for intuitive slider
+        if k < 1: k = 1
+        # Pixel size logic
+        pix_size = max(5, int(intensity))
+        
+        small = cv2.resize(roi, (max(1, w_roi//pix_size), max(1, h_roi//pix_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
+        
+    elif style == "gaussian":
+        k = (int(intensity) * 2) + 1
+        blurred = cv2.GaussianBlur(roi, (k, k), 0)
+        image[y:y+h, x:x+w] = blurred
+        
+    elif style == "solid":
+        cv2.rectangle(image, (x, y), (x+w, y+h), (0,0,0), -1)
+        
+    return image
 
-def recognize_video(video_file, progress=gr.Progress()):
-    """Process video and recognize faces across frames with temporal smoothing."""
-    if video_file is None:
-        return None, "⚠️ No video provided"
+def draw_label(image, x, y, w, text, color, on_blur=False):
+    """Annotation step: Draws text. If on_blur is True, uses high contrast background."""
+    font = cv2.FONT_HERSHEY_SIMPLEX
+    scale = 0.6
+    thickness = 2
+    (tw, th), _ = cv2.getTextSize(text, font, scale, thickness)
     
-    try:
-        detector = get_global_detector()
-        db = get_face_database()
-        
-        cap = cv2.VideoCapture(video_file.name)
-        if not cap.isOpened():
-            return None, "❌ Cannot open video file"
-        
-        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_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-        
-        output_path = create_temp_file(suffix=".mp4")
-        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
-        out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
-        
-        # ✅ NEW: Frame processing optimization
-        PROCESS_EVERY_N_FRAMES = 15  # Only run DeepFace every 15 frames
-        
-        frame_count = 0
-        total_detections = 0
-        known_detections = {}
-        
-        # ✅ NEW: Temporal smoothing - cache recognition results
-        last_recognition_results = {}  # {face_position_key: recognition_data}
-        
-        logger.info(f"📹 Processing video: {total_frames} frames at {fps} FPS")
-        logger.info(f"⚡ Performance mode: Processing every {PROCESS_EVERY_N_FRAMES}th frame")
-        
-        while cap.isOpened():
-            ret, frame = cap.read()
-            if not ret:
-                break
-            
-            frame_count += 1
-            progress(frame_count / total_frames, desc=f"Frame {frame_count}/{total_frames}")
-            
-            frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-            
-            # ✅ NEW: Smart frame processing
-            if frame_count % PROCESS_EVERY_N_FRAMES == 0:
-                # Run FULL recognition (expensive - includes DeepFace)
-                faces, _ = detector.detect_faces(frame_rgb, FIXED_CONFIDENCE, recognize=True)
-                
-                # Update recognition cache
-                last_recognition_results = {}
-                for face in faces:
-                    # Create position-based key for tracking
-                    face_key = (face['x'] // 50, face['y'] // 50)
-                    last_recognition_results[face_key] = {
-                        'match': face.get('match', False),
-                        'person_id': face.get('person_id', 'unknown'),
-                        'name': face.get('name', 'Unknown'),
-                        'distance': face.get('distance', 999)
-                    }
-                
-                logger.info(f"Frame {frame_count}: Full recognition - {len(faces)} faces")
-            else:
-                # Just detect (FAST - no DeepFace), apply cached recognition
-                faces, _ = detector.detect_faces(frame_rgb, FIXED_CONFIDENCE, recognize=False)
+    # If face is blurred, we put the text right in the center of the face box
+    if on_blur:
+        center_x = x + (w // 2) - (tw // 2)
+        center_y = y + (w // 2)
+        
+        # Draw filled box behind text for readability
+        cv2.rectangle(image, (center_x - 5, center_y - th - 5), (center_x + tw + 5, center_y + 5), color, -1)
+        # White text
+        cv2.putText(image, text, (center_x, center_y), font, scale, (255, 255, 255), thickness)
+    else:
+        # Standard bounding box look (Top of box)
+        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, sensitivity, blur_style, blur_amount):
+    """
+    THE MASTER FUNCTION.
+    Modes:
+    1. "privacy" -> Detect + Blur (No ID)
+    2. "data"    -> Detect + Recognize (No Blur)
+    3. "smart"   -> Detect + Recognize + Blur + ID Overlay
+    """
+    if image is None: return None
+    
+    # 1. Detection (The Snapshot)
+    # ---------------------------
+    conf = 0.3 if sensitivity == "High" else 0.5
+    faces = GLOBAL_DETECTOR.detect(image, conf=conf)
+    
+    processed_img = image.copy()
+    
+    for face in faces:
+        x, y, w, h = face['box']
+        
+        # 2. Analysis (The "Ghost" Step)
+        # ---------------------------
+        identity = {"name": "", "color": (0, 255, 0)}
+        
+        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)
                 
-                # Apply cached recognition to detected faces
-                for face in faces:
-                    face_key = (face['x'] // 50, face['y'] // 50)
-                    
-                    # Look for cached result near this position
-                    cached = None
-                    for key, result in last_recognition_results.items():
-                        # Check if face is in similar position (within 2 grid cells)
-                        if abs(key[0] - face_key[0]) <= 2 and abs(key[1] - face_key[1]) <= 2:
-                            cached = result
-                            break
+                if res['match']:
+                    label_text = f"ID: {res['id']} ({res['name']})"
+                else:
+                    label_text = "Unknown"
                     
-                    if cached:
-                        face['match'] = cached['match']
-                        face['person_id'] = cached['person_id']
-                        face['name'] = cached['name']
-                        face['distance'] = cached['distance']
-                    else:
-                        face['match'] = False
-                        face['person_id'] = 'unknown'
-                        face['name'] = 'Unknown'
+                identity = {"name": label_text, "color": res['color']}
+
+        # 3. Modification & Annotation
+        # ---------------------------
+        
+        # -- Mode 1: Raw Privacy --
+        if mode == "privacy":
+            # Just destroy pixels. No data.
+            processed_img = apply_blur(processed_img, x, y, w, h, blur_style, blur_amount)
             
-            # ✅ Redraw annotations with current/cached results
-            annotated_rgb = frame_rgb.copy()
-            for face in faces:
-                x1, y1 = face['x'], face['y']
-                x2, y2 = x1 + face['width'], y1 + face['height']
-                
-                if face.get('match', False):
-                    color = (0, 255, 0)
-                    label = f"{face['name']} ({face['person_id']})"
-                else:
-                    color = (255, 0, 0)
-                    label = "Unknown"
-                
-                cv2.rectangle(annotated_rgb, (x1, y1), (x2, y2), color, 3)
-                (w, h), _ = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, 0.6, 2)
-                cv2.rectangle(annotated_rgb, (x1, y1 - h - 10), (x1 + w, y1), color, -1)
-                cv2.putText(annotated_rgb, label, (x1, y1 - 5),
-                          cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 2)
+        # -- Mode 2: Data Layer --
+        elif mode == "data":
+            # No pixel destruction. Just data boxes.
+            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)
             
-            # Count detections for statistics
-            for face in faces:
-                total_detections += 1
-                if face.get("match"):
-                    person_id = face.get("person_id")
-                    if person_id not in known_detections:
-                        known_detections[person_id] = 0
-                    known_detections[person_id] += 1
+        # -- Mode 3: Smart Redaction (The Demo Winner) --
+        elif mode == "smart":
+            # A. Destroy Pixels (Blur)
+            processed_img = apply_blur(processed_img, x, y, w, h, blur_style, blur_amount)
             
-            # Write frame to output
-            annotated_bgr = cv2.cvtColor(annotated_rgb, cv2.COLOR_RGB2BGR)
-            out.write(annotated_bgr)
+            # B. Overlay Data (The "Ghost" data applied back on top)
+            draw_label(processed_img, x, y, w, identity['name'], identity['color'], on_blur=True)
             
-            if frame_count % 30 == 0:
-                logger.info(f"Processed {frame_count}/{total_frames}")
-        
-        cap.release()
-        out.release()
-        
-        # Generate results summary
-        result = f"### 📊 Video Processing Complete\n\n"
-        result += f"**Frames:** {frame_count} | **Duration:** {frame_count/fps:.1f}s\n"
-        result += f"**Total Detections:** {total_detections}\n\n"
-        
-        if known_detections:
-            result += f"**Recognized People:**\n"
-            persons = db.get_all_persons()
-            for person_id, count in known_detections.items():
-                name = next((p['name'] for p in persons if p['id'] == person_id), "Unknown")
-                result += f"- {name} (ID: {person_id}): {count} times\n"
-        else:
-            result += f"**No known people detected**\n"
-        
-        unknown = total_detections - sum(known_detections.values())
-        if unknown > 0:
-            result += f"\n**Unknown faces:** {unknown} detections\n"
-        
-        logger.info(f"✅ Video complete: {output_path}")
-        return output_path, result
-        
-    except Exception as e:
-        logger.error(f"Error: {e}")
-        return None, f"❌ Error: {str(e)}"
+    return processed_img
 
-def recognize_webcam(image):
-    """Recognize faces in webcam stream."""
-    if image is None:
-        return None
-    try:
-        detector = get_global_detector()
-        _, annotated = detector.detect_faces(image, FIXED_CONFIDENCE, recognize=True)
-        return annotated
-    except Exception as e:
-        logger.error(f"Webcam error: {e}")
-        return image
-
-def add_person_handler(person_id, name, image):
-    """Add person to database."""
-    if not person_id or not name:
-        return "⚠️ Please provide ID and Name", refresh_people_list()
-    if image is None:
-        return "⚠️ Please upload an image", refresh_people_list()
-    
-    db = get_face_database()
-    success, message = db.add_person(person_id, name, image)
-    return message, refresh_people_list()
-
-def delete_person_handler(person_id):
-    """Delete person from database."""
-    if not person_id:
-        return "⚠️ Please provide Person ID", refresh_people_list()
-    
-    db = get_face_database()
-    success, message = db.delete_person(person_id)
-    return message, refresh_people_list()
-
-def refresh_people_list():
-    """Get formatted list of all people."""
-    db = get_face_database()
-    persons = db.get_all_persons()
-    
-    if not persons:
-        return "### 📭 Database is Empty\n\nAdd people using the form above!"
-    
-    result = f"### 👥 Registered People ({len(persons)})\n\n"
-    for p in sorted(persons, key=lambda x: x['id']):
-        result += f"- **{p['name']}** (ID: `{p['id']}`)\n"
+# ====================================================
+# 5. VIDEO PROCESSING HELPERS
+# ====================================================
+def process_video_general(video_path, mode, sensitivity, blur_style, blur_amount, progress=gr.Progress()):
+    """Generic video processor for all tabs."""
+    if not video_path: return None
     
-    return result
+    cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened(): return None
 
-def get_database_stats():
-    """Get database statistics."""
-    db = get_face_database()
-    if not CHROMADB_AVAILABLE or db.collection is None:
-        return "### ⚠️ ChromaDB Not Available"
+    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))
     
-    count = db.collection.count()
-    persons = db.get_all_persons()
-    
-    stats = f"### 📊 Database Statistics\n\n"
-    stats += f"- **Total Embeddings:** {count}\n"
-    stats += f"- **Unique People:** {len(persons)}\n"
-    stats += f"- **Status:** {'✅ Active' if count > 0 else '📭 Empty'}\n\n"
-    
-    if db.hf_api and db.hf_token and db.space_id:
-        stats += f"- **Auto-Commit:** ✅ Enabled\n"
-    else:
-        stats += f"- **Auto-Commit:** ⚠️ Disabled\n"
+    out_path = create_temp_file()
+    # Attempt h264, fallback to mp4v
+    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))
     
-    return stats
+    cnt = 0
+    while cap.isOpened():
+        ret, frame = cap.read()
+        if not ret: break
+        
+        # Process using the Master Function
+        res_frame = process_frame(frame, mode, sensitivity, blur_style, blur_amount)
+        
+        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.release()
+    return out_path
 
 # ====================================================
-# GRADIO UI
+# 6. GRADIO INTERFACE (The Story Flow)
 # ====================================================
-with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue"), title="Face Recognition") as demo:
-    gr.Markdown("# 🎭 Face Recognition System")
-    gr.Markdown("**YOLO + DeepFace + ChromaDB** • Image, Video & Webcam Support")
-    
-    if not DEEPFACE_AVAILABLE or not CHROMADB_AVAILABLE:
-        gr.Markdown("### ⚠️ Missing Dependencies")
-        if not DEEPFACE_AVAILABLE:
-            gr.Markdown("- Install: `pip install deepface tf-keras`")
-        if not CHROMADB_AVAILABLE:
-            gr.Markdown("- Install: `pip install chromadb`")
 
+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")
+    
     with gr.Row():
+        # LEFT COLUMN: SETTINGS
+        with gr.Column(scale=1, variant="panel"):
+            gr.Markdown("### ⚙️ Global Configuration")
+            
+            # Global status check
+            db_status = gr.Markdown(f"**Database Status:** {FACE_DB.get_stats()}")
+            
+            blur_style = gr.Radio(["pixelate", "gaussian", "solid"], label="Blur Style", value="pixelate")
+            blur_amount = gr.Slider(5, 50, value=25, label="Blur Intensity")
+            sensitivity = gr.Radio(["Balanced", "High"], label="Detection Sensitivity", value="Balanced")
+            
+            gr.Info("ℹ️ Tip: Images in 'known_faces' folder are loaded automatically.")
+
+        # RIGHT COLUMN: THE 3 TABS - THE STORY
         with gr.Column(scale=3):
             with gr.Tabs():
-                with gr.TabItem("🎭 Face Recognition"):
+                
+                # --- 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.*")
+                    
                     with gr.Tabs():
-                        with gr.TabItem("📷 Image"):
-                            with gr.Row():
-                                img_in = gr.Image(
-                                    sources=["upload", "clipboard"],
-                                    type="numpy",
-                                    label="Input Image",
-                                    height=500
-                                )
-                                with gr.Column():
-                                    img_out = gr.Image(
-                                        type="numpy",
-                                        label="Recognition Result",
-                                        height=400
-                                    )
-                                    img_status = gr.Markdown("_Upload an image_")
+                        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")
                             
-                            with gr.Row():
-                                recognize_btn = gr.Button("🔍 Recognize Faces", variant="primary", scale=3)
-                                gr.ClearButton([img_in, img_out, img_status], scale=1)
+                        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")
                             
-                            # EXAMPLES SECTION
-                            gr.Examples(
-                                examples=[
-                                    ["examples/messi_test.webp"],
-                                    ["examples/mark_test.webp"],
-                                    ["examples/group_photo.png"],
-                                    ["examples/group2.webp"],
-                                    ["examples/not_face_1.jpg"],
-                                    ["examples/single_face.jpg"],
-                                    ["examples/two_faces.png"],
-                                ],
-                                inputs=img_in,
-                                label="Example Images - Click to Try"
-                            )
-                        
-                        with gr.TabItem("🎥 Video"):
-                            with gr.Row():
-                                vid_in = gr.File(
-                                    file_types=[".mp4", ".avi", ".mov", ".mkv"],
-                                    label="Upload Video File"
-                                )
-                                with gr.Column():
-                                    vid_out = gr.Video(
-                                        label="Processed Video",
-                                        height=400
-                                    )
-                                    vid_status = gr.Markdown("_Upload a video_")
-                            
-                            with gr.Row():
-                                process_vid_btn = gr.Button("🔍 Process Video", variant="primary", scale=3)
-                                gr.ClearButton([vid_in, vid_out, vid_status], scale=1)                          
-                        
-                        with gr.TabItem("📹 Webcam"):
-                            with gr.Row():
-                                web_in = gr.Image(
-                                    sources=["webcam"],
-                                    type="numpy",
-                                    streaming=True,
-                                    label="Live Feed",
-                                    height=500
-                                )
-                                web_out = gr.Image(
-                                    type="numpy",
-                                    label="Recognition",
-                                    height=500
-                                )
-                
-                with gr.TabItem("🗄️ Database"):
-                    with gr.Row():
-                        db_stats = gr.Markdown(value="Loading...")
-                    
-                    gr.Markdown("---")
+                        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.*")
                     
-                    with gr.Row():
-                        with gr.Column():
-                            gr.Markdown("#### ➕ Add Person")
-                            gr.Markdown("💡 *Tip: Add same person 5-10 times with different angles for better recognition*")
-                            add_id = gr.Textbox(label="Person ID", placeholder="004")
-                            add_name = gr.Textbox(label="Name", placeholder="Alice")
-                            add_img = gr.Image(
-                                sources=["upload", "webcam"],
-                                type="numpy",
-                                label="Face Photo"
-                            )
-                            add_btn = gr.Button("Add to Database", variant="primary")
-                            add_status = gr.Markdown("")
-                        
-                        with gr.Column():
-                            gr.Markdown("#### 🗑️ Delete Person")
-                            del_id = gr.Textbox(label="Person ID", placeholder="004")
-                            del_btn = gr.Button("Delete", variant="stop")
-                            del_status = gr.Markdown("")
+                    with gr.Tabs():
+                        with gr.TabItem("Image"):
+                            d_img_in = gr.Image(label="Input", type="numpy", height=400)
+                            d_img_out = gr.Image(label="Data Output", height=400)
+                            d_btn = gr.Button("Analyze Data", variant="primary")
+                            
+                        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.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.*")
                     
-                    gr.Markdown("---")
-                    people_list = gr.Markdown(value="Loading...")
-                    refresh_btn = gr.Button("🔄 Refresh List")
-
-    # Event Handlers
-    recognize_btn.click(
-        recognize_image,
-        inputs=[img_in],
-        outputs=[img_out, img_status]
-    )
+                    with gr.Tabs():
+                        with gr.TabItem("Image"):
+                            s_img_in = gr.Image(label="Input", type="numpy", height=400)
+                            s_img_out = gr.Image(label="Smart Redaction Output", height=400)
+                            s_btn = gr.Button("Apply Smart Redaction", variant="primary")
+                            
+                        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 (Wiring the Logic)
+    # =========================================
     
-    process_vid_btn.click(
-        recognize_video,
-        inputs=[vid_in],
-        outputs=[vid_out, vid_status]
-    )
+    # Tab 1: Privacy (Mode="privacy")
+    p_btn.click(lambda img, s, b, a: process_frame(img, "privacy", s, b, a), 
+                inputs=[p_img_in, sensitivity, blur_style, blur_amount], outputs=p_img_out)
     
-    web_in.stream(
-        recognize_webcam,
-        inputs=[web_in],
-        outputs=web_out
-    )
+    p_vid_btn.click(lambda vid, s, b, a: process_video_general(vid, "privacy", s, b, a), 
+                    inputs=[p_vid_in, sensitivity, blur_style, blur_amount], outputs=p_vid_out)
     
-    add_btn.click(
-        add_person_handler,
-        inputs=[add_id, add_name, add_img],
-        outputs=[add_status, people_list]
-    )
+    p_web_in.stream(lambda img, s, b, a: process_frame(img, "privacy", s, b, a), 
+                    inputs=[p_web_in, sensitivity, blur_style, blur_amount], outputs=p_web_out)
+
+    # Tab 2: Data (Mode="data")
+    d_btn.click(lambda img, s, b, a: process_frame(img, "data", s, b, a), 
+                inputs=[d_img_in, sensitivity, blur_style, blur_amount], outputs=d_img_out)
+    
+    d_vid_btn.click(lambda vid, s, b, a: process_video_general(vid, "data", s, b, a), 
+                    inputs=[d_vid_in, sensitivity, blur_style, blur_amount], outputs=d_vid_out)
     
-    del_btn.click(
-        delete_person_handler,
-        inputs=[del_id],
-        outputs=[del_status, people_list]
-    )
+    d_web_in.stream(lambda img, s, b, a: process_frame(img, "data", s, b, a), 
+                    inputs=[d_web_in, sensitivity, blur_style, blur_amount], outputs=d_web_out)
+
+    # Tab 3: Smart (Mode="smart")
+    s_btn.click(lambda img, s, b, a: process_frame(img, "smart", s, b, a), 
+                inputs=[s_img_in, sensitivity, blur_style, blur_amount], outputs=s_img_out)
     
-    refresh_btn.click(
-        refresh_people_list,
-        outputs=people_list
-    )
+    s_vid_btn.click(lambda vid, s, b, a: process_video_general(vid, "smart", s, b, a), 
+                    inputs=[s_vid_in, sensitivity, blur_style, blur_amount], outputs=s_vid_out)
     
-    demo.load(get_database_stats, outputs=db_stats)
-    demo.load(refresh_people_list, outputs=people_list)
+    s_web_in.stream(lambda img, s, b, a: process_frame(img, "smart", s, b, a), 
+                    inputs=[s_web_in, sensitivity, blur_style, blur_amount], outputs=s_web_out)
 
-# ====================================================
-# MAIN
-# ====================================================
 if __name__ == "__main__":
-    logger.info("🚀 Starting Face Recognition System...")
+    # Ensure models are loaded before UI starts
     try:
-        get_global_detector()
-        get_face_database()
-        logger.info("✅ Ready! Launching...")
+        # Trigger singleton init
+        if GLOBAL_DETECTOR:
+            logger.info("✅ System Ready. Launching...")
         demo.launch()
     except Exception as e:
-        logger.error(f"❌ Startup failed: {e}")
+        logger.error(f"Startup Failed: {e}")