Update app.py

app.py

@@ -1,14 +1,10 @@
-# [FINAL] Intelligent Face Privacy Tool
-# Merges YOLOv8 detection, DeepFace recognition, and blurring into a single, robust workflow.
-
 # --- 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
 
@@ -18,37 +14,46 @@ import numpy as np
 import gradio as gr
 from ultralytics import YOLO
 
-# --- Optional Face Recognition & Database Libraries ---
+# --- 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 be disabled. Install with: pip install deepface")
+    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 be disabled. Install with: pip install chromadb")
+    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__)
 
 # ====================================================
-# SHARED UTILITIES
+# 1. CONFIGURATION & UTILITIES
 # ====================================================
 
-# --- Temporary File Cleanup ---
+# --- HYBRID PRIVACY SETTINGS ---
+CONFIDENCE_THRESHOLD = 0.3   # High Sensitivity (Catches mostly everything)
+TARGET_MOSAIC_GRID = 12      # Max Resolution: Face is divided into 12x12 grid
+MIN_PIXEL_SIZE = 12          # Min Block Size: Blocks cannot be smaller than 12px
+COVERAGE_SCALE = 1.1         # 110% Coverage (Padding around face)
+
 TEMP_FILES = []
+
 def cleanup_temp_files():
+    """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 temp file: {f}")
-        except Exception as e:
-            logger.warning(f"⚠️ Failed to delete temp file {f}: {e}")
+            if os.path.exists(f):
+                os.remove(f)
+        except Exception:
+            pass
+
 atexit.register(cleanup_temp_files)
 
 def create_temp_file(suffix=".mp4") -> str:
@@ -56,370 +61,448 @@ def create_temp_file(suffix=".mp4") -> str:
     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:
-    return SENSITIVITY_MAP.get(sensitivity, 0.5)
-
 # ====================================================
-# CONFIGURATION DATA CLASSES
+# 2. THE DATABASE LAYER (Backend Only - No UI)
 # ====================================================
-
-@dataclass
-class BlurConfig:
-    type: str = "pixelate"
-    intensity: float = 25.0
-    pixel_size: int = 25
-    scaling_factor: float = 1.1
-
-@dataclass
-class DetectionConfig:
-    model_path: str = "yolov8n-face.pt"
-
-# ====================================================
-# BLUR EFFECTS (Strategy Pattern)
-# ====================================================
-
-class BlurEffect(ABC):
-    def __init__(self, config: BlurConfig): self.config = config
-    @abstractmethod
-    def apply(self, image: np.ndarray, roi: Tuple[int, int, int, int]) -> np.ndarray: pass
-
-class PixelateBlur(BlurEffect):
-    def apply(self, image: np.ndarray, roi: Tuple[int, int, int, int]) -> np.ndarray:
-        x, y, w, h = roi
-        face_roi = image[y:y+h, x:x+w]
-        if face_roi.size == 0: return image
-        h_roi, w_roi = face_roi.shape[:2]
-        pixel_size = max(1, self.config.pixel_size)
-        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 GaussianBlur(BlurEffect):
-    def apply(self, image: np.ndarray, roi: Tuple[int, int, int, int]) -> np.ndarray:
-        x, y, w, h = roi
-        face_roi = image[y:y+h, x:x+w]
-        if face_roi.size == 0: return image
-        kernel_val = int(self.config.intensity) | 1
-        blurred_roi = cv2.GaussianBlur(face_roi, (kernel_val, kernel_val), 0)
-        image[y:y+h, x:x+w] = blurred_roi
-        return image
-
-def get_blur_effect(config: BlurConfig) -> BlurEffect:
-    effects = {"pixelate": PixelateBlur, "gaussian": GaussianBlur}
-    cls = effects.get(config.type)
-    if not cls: raise ValueError(f"Unknown blur type: {config.type}")
-    return cls(config)
-
-# ====================================================
-# FACE DATABASE (ChromaDB + DeepFace)
-# ====================================================
-
 class FaceDatabase:
-    def __init__(self, db_path: str = "./chroma_db", known_faces_dir: str = "known_faces", model_name: str = "Facenet512"):
-        self.model_name = model_name
-        self.known_faces_dir = Path(known_faces_dir)
-        self.is_ready = False
+    """
+    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.error("❌ DeepFace or ChromaDB not available. Face recognition is disabled.")
+            logger.warning("❌ Database unavailable (Missing dependencies)")
             return
 
-        logger.info("🔧 Initializing Face Database...")
         try:
-            client = chromadb.PersistentClient(path=db_path)
-            self.collection = client.get_or_create_collection(name="face_embeddings", metadata={"hnsw:space": "cosine"})
-            self._index_known_faces()
-            self.is_ready = self.collection.count() > 0
-            if not self.is_ready:
-                logger.warning("⚠️ Face database is empty. All faces will be marked as 'Unknown'.")
+            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
+            
+            # Auto-index on startup
+            if self.faces_dir.exists():
+                self._scan_and_index()
             else:
-                logger.info(f"✅ Face database ready with {self.collection.count()} known faces.")
+                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}")
-
-    def _get_image_hash(self, img_path: Path) -> str:
-        with open(img_path, 'rb') as f: return hashlib.md5(f.read()).hexdigest()
-
-    def _index_known_faces(self):
-        if not self.known_faces_dir.exists():
-            logger.info(f"📁 Creating '{self.known_faces_dir}' directory for known faces.")
-            self.known_faces_dir.mkdir(parents=True, exist_ok=True)
-            return
-
-        logger.info(f"🔄 Scanning '{self.known_faces_dir}' for faces to index...")
-        indexed_count = 0
-        for person_dir in [d for d in self.known_faces_dir.iterdir() if d.is_dir()]:
-            folder_name = person_dir.name
-            parts = folder_name.split('_', 1)
-            if len(parts) != 2:
-                logger.warning(f"⚠️ Skipping folder '{folder_name}'. Use format 'ID_Name' (e.g., '001_John_Doe').")
-                continue
-            person_id, person_name = parts[0], parts[1].replace('_', ' ').title()
-            for img_path in list(person_dir.glob("*.[jp][pn]g")) + list(person_dir.glob("*.webp")):
+            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 _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('_', ' ')
+            
+            images = list(person_dir.glob("*.jpg")) + list(person_dir.glob("*.png")) + list(person_dir.glob("*.webp"))
+            
+            for img_path in images:
                 try:
-                    img_hash = self._get_image_hash(img_path)
-                    if self.collection.get(ids=[img_hash])['ids']: continue
-                    embedding = DeepFace.represent(str(img_path), model_name=self.model_name, enforce_detection=False)[0]["embedding"]
-                    self.collection.add(embeddings=[embedding], metadatas=[{"id": person_id, "name": person_name}], ids=[img_hash])
-                    indexed_count += 1
-                    logger.info(f"✅ Indexed: {person_name} (ID: {person_id}) from {img_path.name}")
+                    img_hash = self._get_hash(img_path)
+                    # Check if already indexed
+                    if self.collection.get(ids=[img_hash])['ids']:
+                        continue
+                        
+                    # Generate Embedding
+                    embedding_objs = DeepFace.represent(
+                        img_path=str(img_path), 
+                        model_name="Facenet512", 
+                        enforce_detection=False
+                    )
+                    
+                    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}")
-        if indexed_count > 0:
-            logger.info(f"💾 Indexed {indexed_count} new faces.")
+                    logger.error(f"⚠️ Failed to index {img_path.name}: {e}")
+        
+        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
 
-    def recognize_face(self, face_image: np.ndarray, threshold: float = 0.4) -> Dict[str, Any]:
-        if not self.is_ready:
-            return {"match": False, "name": "Unknown"}
         try:
-            embedding = DeepFace.represent(face_image, model_name=self.model_name, enforce_detection=False)[0]["embedding"]
-            results = self.collection.query(query_embeddings=[embedding], n_results=1, include=["metadatas", "distances"])
-            if not results['ids'][0]:
-                return {"match": False, "name": "Unknown"}
-            distance, metadata = results['distances'][0][0], results['metadatas'][0][0]
-            if distance < threshold:
-                return {"match": True, "name": metadata.get('name', 'Known'), "id": metadata.get('id', 'N/A')}
-            return {"match": False, "name": "Unknown"}
+            # 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_objs = DeepFace.represent(
+                img_path=temp_path,
+                model_name="Facenet512",
+                enforce_detection=False
+            )
+            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=[query_embed],
+                n_results=1
+            )
+
+            if not results['ids'][0]: return default
+
+            distance = results['distances'][0][0]
+            metadata = results['metadatas'][0][0]
+
+            # Threshold: Lower is stricter. 0.45 is a good balance for Facenet512
+            if distance < 0.45:
+                return {
+                    "match": True,
+                    "name": metadata['name'],
+                    "id": metadata['id'],
+                    "color": (0, 255, 0) # Green for match
+                }
+            return default
+
         except Exception as e:
-            logger.warning(f"⚠️ Recognition failed for a face: {e}")
-            return {"match": False, "name": "Unknown"}
+            logger.error(f"Recognition Error: {e}")
+            return default
+
+    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)"
+
+# Singleton DB
+FACE_DB = FaceDatabase()
 
 # ====================================================
-# UNIFIED FACE DETECTOR
+# 3. THE UNIFIED DETECTOR (YOLO)
 # ====================================================
-
-class YOLOv8FaceDetector:
-    def __init__(self, config: DetectionConfig):
+class Detector:
+    def __init__(self):
+        logger.info("📦 Loading YOLOv8-Face...")
         try:
-            self.model = YOLO(config.model_path)
-            logger.info("✅ YOLOv8 face model loaded successfully.")
+            self.model = YOLO("yolov8n-face.pt")
+            logger.info("✅ Model Loaded.")
         except Exception as e:
-            raise RuntimeError(f"❌ Failed to load YOLOv8 model: {e}")
-
-    def detect_faces(self, image: np.ndarray, conf_threshold: float, face_db: Optional[FaceDatabase]) -> List[Dict[str, Any]]:
-        results = self.model(image, conf=conf_threshold, verbose=False)
-        detected_faces = []
+            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 = []
         for r in results:
             if r.boxes is None: continue
             for box in r.boxes:
                 x1, y1, x2, y2 = map(int, box.xyxy[0])
-                face_info = {"box": (x1, y1, x2 - x1, y2 - y1)}
-                
-                # Perform recognition if a database is provided
-                if face_db and face_db.is_ready:
-                    face_crop = image[y1:y2, x1:x2]
-                    if face_crop.size > 0:
-                        rec_result = face_db.recognize_face(face_crop)
-                        face_info.update(rec_result)
-                    else:
-                        face_info.update({"match": False, "name": "Unknown"})
-                else:
-                    face_info.update({"match": False, "name": "Unknown"})
-                
-                detected_faces.append(face_info)
-        return detected_faces
+                faces.append({
+                    "box": (x1, y1, x2-x1, y2-y1),
+                    "conf": float(box.conf[0])
+                })
+        return faces
+
+GLOBAL_DETECTOR = Detector()
 
 # ====================================================
-# CORE APPLICATION LOGIC
+# 4. CORE LOGIC
 # ====================================================
 
-class IntelligentPrivacyApp:
-    def __init__(self, blur_config: BlurConfig, detector: YOLOv8FaceDetector, face_db: Optional[FaceDatabase]):
-        self.blur_effect = get_blur_effect(blur_config)
-        self.detector = detector
-        self.face_db = face_db
-        self.blur_config = blur_config
+def apply_blur(image, x, y, w, h):
+    """
+    HYBRID ADAPTIVE BLUR:
+    - Uses Adaptive Grid (12 blocks) for Big Faces.
+    - Uses Min Pixel Size (12px) for Small Faces to force lower resolution.
+    """
+    h_img, w_img = image.shape[:2]
+    
+    # --- COVERAGE AREA 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]
+    
+    # --- HYBRID LOGIC ---
+    # 1. Max blocks allowed by Adaptive Rule
+    grid_adaptive = TARGET_MOSAIC_GRID
+    
+    # 2. Max blocks allowed by Min Pixel Rule
+    # If face is 100px wide, and min pixel is 12px, we allow max 8 blocks.
+    grid_pixel_limit = max(1, w_roi // MIN_PIXEL_SIZE)
+    
+    # 3. Take the stricter (lower) grid count
+    final_grid_size = min(grid_adaptive, grid_pixel_limit)
+    final_grid_size = max(2, final_grid_size) # Ensure at least 2x2
+    
+    # Calculate Block Dimensions
+    aspect = w_roi / h_roi
+    target_w = final_grid_size
+    target_h = int(final_grid_size / aspect)
+    
+    target_w = max(2, target_w)
+    target_h = max(2, target_h)
+
+    # 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)
     
-    def _expand_bbox(self, box: Tuple[int, int, int, int]) -> Tuple[int, int, int, int]:
-        x, y, w, h = box
-        new_w = int(w * self.blur_config.scaling_factor)
-        new_h = int(h * self.blur_config.scaling_factor)
-        x_offset, y_offset = (new_w - w) // 2, (new_h - h) // 2
-        return max(0, x - x_offset), max(0, y - y_offset), new_w, new_h
-
-    def process_frame(self, frame: np.ndarray, conf_threshold: float, mode: str) -> np.ndarray:
-        processed_frame = frame.copy()
+    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']
         
-        try:
-            faces = self.detector.detect_faces(processed_frame, conf_threshold, self.face_db if mode == "intelligent" else None)
-        except Exception as e:
-            logger.error(f"❌ Face detection failed: {e}")
-            gr.Warning("Face detection process failed. Cannot process frame.")
-            return frame # Return original frame on critical error
-
-        for face in faces:
-            # Always apply blur
-            expanded_box = self._expand_bbox(face["box"])
-            processed_frame = self.blur_effect.apply(processed_frame, expanded_box)
-            
-            # Apply label on top of blur if in intelligent mode
-            if mode == "intelligent":
-                is_known = face.get("match", False)
-                label = face.get("name", "Unknown") if is_known else "Unknown"
-                color = (0, 255, 0) if is_known else (255, 0, 0)
-                
-                x, y, _, _ = face["box"]
-                (w, h), _ = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, 0.6, 2)
-                
-                # Draw label background
-                label_y_pos = y - 10
-                bg_y1 = label_y_pos - h - 5
-                bg_y2 = label_y_pos + 5
-                cv2.rectangle(processed_frame, (x, bg_y1), (x + w, bg_y2), color, -1)
+        # 2. Analysis
+        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)
                 
-                # Draw label text
-                cv2.putText(processed_frame, label, (x, label_y_pos), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 2)
+                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)
+            
+        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)
+            
+        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)
+            
+    # Create Log String
+    if not log_entries:
+        final_log = "No faces detected."
+    else:
+        final_log = "--- Detection Report ---\n" + "\n".join(log_entries)
 
-        return processed_frame
+    return processed_img, final_log
 
 # ====================================================
-# GRADIO HANDLER FUNCTIONS
+# 5. VIDEO PROCESSING HELPERS
 # ====================================================
-
-# --- Global Instances ---
-DETECTOR = YOLOv8FaceDetector(DetectionConfig())
-FACE_DB = FaceDatabase()
-
-def get_app_instance(blur_type: str, blur_amount: float, blur_size: float) -> IntelligentPrivacyApp:
-    blur_config = BlurConfig(
-        type=blur_type,
-        intensity=blur_amount,
-        pixel_size=int(blur_amount),
-        scaling_factor=blur_size
-    )
-    return IntelligentPrivacyApp(blur_config, DETECTOR, FACE_DB)
-
-def process_media(media, blur_type, blur_amount, blur_size, sensitivity, mode, progress=gr.Progress()):
-    if media is None: return None, "No media provided."
+def process_video_general(video_path, mode, progress=gr.Progress()):
+    """Generic video processor."""
+    if not video_path: return None
     
-    app = get_app_instance(blur_type, blur_amount, blur_size)
-    confidence = get_confidence_from_sensitivity(sensitivity)
-
-    # --- Image Processing ---
-    if isinstance(media, np.ndarray):
-        result = app.process_frame(media, confidence, mode)
-        return result, "Image processing complete."
+    cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened(): return None
 
-    # --- Video Processing ---
-    if hasattr(media, 'name'):
-        try:
-            cap = cv2.VideoCapture(media.name)
-            if not cap.isOpened(): return None, "❌ Cannot open video file."
-
-            out_path = create_temp_file()
-            fourcc = cv2.VideoWriter_fourcc(*'mp4v')
-            fps, w, h = cap.get(cv2.CAP_PROP_FPS), int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)), int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-            total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-            out_vid = cv2.VideoWriter(out_path, fourcc, fps, (w, h))
-
-            for frame_num in progress.tqdm(range(total_frames), desc="Processing Video"):
-                ret, frame = cap.read()
-                if not ret: break
-                processed_frame = app.process_frame(frame, confidence, mode)
-                out_vid.write(processed_frame)
-            
-            cap.release(); out_vid.release()
-            return out_path, f"✅ Video processing complete ({total_frames} frames)."
-        except Exception as e:
-            logger.error(f"❌ Video processing error: {e}")
-            gr.Error(f"Video processing failed: {e}")
-            return None, f"❌ Error: {e}"
+    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))
     
-    return None, "Unsupported media type."
-
-def process_stream(frame, blur_type, blur_amount, blur_size, sensitivity, mode):
-    if frame is None: return None
-    app = get_app_instance(blur_type, blur_amount, blur_size)
-    confidence = get_confidence_from_sensitivity(sensitivity)
-    return app.process_frame(frame, confidence, mode)
+    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
+        
+        # Process using the Master Function (Ignore log for video)
+        res_frame, _ = process_frame(frame, mode)
+        
+        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
 # ====================================================
-with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue"), title="Intelligent Face Privacy Tool") as demo:
-    gr.Markdown("# 🎯 Intelligent Face Privacy Tool")
-    gr.Markdown("An advanced tool to apply context-aware privacy to faces in media. Faces are blurred and labeled as 'Known' or 'Unknown'.")
-
-    if not DEEPFACE_AVAILABLE or not CHROMADB_AVAILABLE:
-        gr.Markdown("### ⚠️ Recognition Features Disabled\n`deepface` or `chromadb` not found. 'Intelligent Privacy' mode will label all faces as 'Unknown'.\nInstall with: `pip install deepface 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")
+    
+    # Unified Config Info Row
     with gr.Row():
-        # ========== SETTINGS SIDEBAR ==========
-        with gr.Column(scale=1):
-            with gr.Column(variant="panel"):
-                gr.Markdown("### ⚙️ Processing Settings")
-                detection_sensitivity = gr.Radio(
-                    choices=list(SENSITIVITY_MAP.keys()), value="Balanced (Default)",
-                    label="Detection Sensitivity", info="How strict the face detection should be."
-                )
-                with gr.Accordion("Blur Customization", open=True):
-                    blur_type = gr.Radio(["pixelate", "gaussian"], value="pixelate", label="Blur Type")
-                    blur_amount = gr.Slider(5, 100, step=1, value=25, label="Blur Intensity / Pixel Size")
-                    blur_size = gr.Slider(1.0, 1.5, step=0.05, value=1.1, label="Coverage Area (Scale)")
-
-        # ========== MAIN CONTENT AREA ==========
-        with gr.Column(scale=3):
+        gr.Markdown(f"**System Status:** {FACE_DB.get_stats()}")
+        gr.Markdown(f"**Config:** Hybrid Pixelate | High Sensitivity | 110% Coverage")
+
+    with gr.Tabs():
+        
+        # --- 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():
-                # ========== INTELLIGENT PRIVACY TAB ==========
-                with gr.TabItem("🎯 Intelligent Privacy"):
-                    gr.Markdown("### Blur all faces and label them as 'Known' or 'Unknown'.")
-                    with gr.Tabs() as intelligent_tabs:
-                        with gr.TabItem("📷 Image"):
-                            with gr.Row():
-                                img_in_intel = gr.Image(sources=["upload", "clipboard"], type="numpy", label="Input Image", height=400)
-                                img_out_intel = gr.Image(type="numpy", label="Processed Image", height=400)
-                            img_status_intel = gr.Markdown()
-                            intel_img_btn = gr.Button("Apply Intelligent Privacy", variant="primary")
-                        with gr.TabItem("🎥 Video"):
-                            with gr.Row():
-                                vid_in_intel = gr.File(file_types=[".mp4", ".mov"], label="Input Video")
-                                with gr.Column():
-                                    vid_out_intel = gr.Video(label="Processed Video", height=400)
-                                    vid_status_intel = gr.Markdown()
-                            intel_vid_btn = gr.Button("Process Video", variant="primary")
-                        with gr.TabItem("📹 Webcam"):
-                            with gr.Row():
-                                web_in_intel = gr.Image(sources=["webcam"], streaming=True, type="numpy", label="Live Webcam", height=400)
-                                web_out_intel = gr.Image(type="numpy", label="Processed Feed", height=400)
-
-                # ========== SIMPLE PRIVACY TAB ==========
-                with gr.TabItem("🔒 Simple Privacy"):
-                    gr.Markdown("### Blur all faces without any labels. Useful for total anonymization.")
-                    with gr.Tabs():
-                        with gr.TabItem("📷 Image"):
-                            with gr.Row():
-                                img_in_simple = gr.Image(sources=["upload", "clipboard"], type="numpy", label="Input Image", height=400)
-                                img_out_simple = gr.Image(type="numpy", label="Protected Image", height=400)
-                            img_status_simple = gr.Markdown()
-                            simple_img_btn = gr.Button("Apply Simple Blur", variant="secondary")
-                        with gr.TabItem("🎥 Video"):
-                            with gr.Row():
-                                vid_in_simple = gr.File(file_types=[".mp4", ".mov"], label="Input Video")
-                                with gr.Column():
-                                    vid_out_simple = gr.Video(label="Protected Video", height=400)
-                                    vid_status_simple = gr.Markdown()
-                            simple_vid_btn = gr.Button("Process Video", variant="secondary")
-                        with gr.TabItem("📹 Webcam"):
-                            with gr.Row():
-                                web_in_simple = gr.Image(sources=["webcam"], streaming=True, type="numpy", label="Live Webcam", height=400)
-                                web_out_simple = gr.Image(type="numpy", label="Protected Feed", height=400)
-
-    # ========== EVENT HANDLERS ==========
-    # --- Intelligent Privacy Mode ---
-    intel_img_btn.click(lambda *args: process_media(*args, mode="intelligent"), [img_in_intel, blur_type, blur_amount, blur_size, detection_sensitivity], [img_out_intel, img_status_intel])
-    intel_vid_btn.click(lambda *args: process_media(*args, mode="intelligent"), [vid_in_intel, blur_type, blur_amount, blur_size, detection_sensitivity], [vid_out_intel, vid_status_intel])
-    web_in_intel.stream(lambda *args: process_stream(*args, mode="intelligent"), [web_in_intel, blur_type, blur_amount, blur_size, detection_sensitivity], web_out_intel)
+                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.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")
+                    
+                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.Tabs():
+                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.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.*")
+            
+            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.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
+    # =========================================
     
-    # --- Simple Privacy Mode ---
-    simple_img_btn.click(lambda *args: process_media(*args, mode="simple"), [img_in_simple, blur_type, blur_amount, blur_size, detection_sensitivity], [img_out_simple, img_status_simple])
-    simple_vid_btn.click(lambda *args: process_media(*args, mode="simple"), [vid_in_simple, blur_type, blur_amount, blur_size, detection_sensitivity], [vid_out_simple, vid_status_simple])
-    web_in_simple.stream(lambda *args: process_stream(*args, mode="simple"), [web_in_simple, blur_type, blur_amount, blur_size, detection_sensitivity], web_out_simple)
+    # Tab 1: Privacy (Mode="privacy")
+    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")
+    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")
+    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 Intelligent Face Privacy Tool...")
-    demo.launch()
+    try:
+        if GLOBAL_DETECTOR:
+            logger.info("✅ System Ready. Launching...")
+        demo.launch()
+    except Exception as e:
+        logger.error(f"Startup Failed: {e}")