Update app.py

app.py

@@ -37,22 +37,27 @@ logger = logging.getLogger(__name__)
 # 1. CONFIGURATION & UTILITIES
 # ====================================================
 
-# --- HYBRID PRIVACY SETTINGS ---
-CONFIDENCE_THRESHOLD = 0.3   # High Sensitivity (Catches mostly everything)
-TARGET_MOSAIC_GRID = 8      # Max Resolution: Face is divided into 12x12 grid, (Lower = Stronger Blur)
-MIN_PIXEL_SIZE = 15          # Min Block Size: Blocks cannot be smaller than 12px, (Higher = Stronger Blur for small faces)
-COVERAGE_SCALE = 1.1         # 110% Coverage (Padding around face)
+# --- TUNED PARAMETERS ---
+# 1. Detection Sensitivity
+DETECTION_CONFIDENCE = 0.4   
+
+# 2. Recognition Strictness (LOWER = STRICTER)
+# 0.30 is the sweet spot for Facenet512. 
+# Anything above 0.40 causes the "Lupita/Spader" identity confusion.
+RECOGNITION_THRESHOLD = 0.30 
+
+# 3. Visual Settings
+TARGET_MOSAIC_GRID = 10      # Resolution of the blur
+MIN_PIXEL_SIZE = 12          # Minimum pixel block size
+COVERAGE_SCALE = 1.2         # 120% Coverage (Padding around face to catch hair/ears)
 
 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)
-        except Exception:
-            pass
+            if os.path.exists(f): os.remove(f)
+        except Exception: pass
 
 atexit.register(cleanup_temp_files)
 
@@ -61,484 +66,290 @@ def create_temp_file(suffix=".mp4") -> str:
     TEMP_FILES.append(path)
     return path
 
+def get_padded_coords(image, x, y, w, h, scale=COVERAGE_SCALE):
+    """
+    UNIFIED COORDINATE SYSTEM:
+    Calculates the padded coordinates once so Blur and Box match perfectly.
+    """
+    h_img, w_img = image.shape[:2]
+    
+    # Calculate padding amount
+    pad_w = int(w * (scale - 1.0) / 2)
+    pad_h = int(h * (scale - 1.0) / 2)
+    
+    # Apply padding with boundary checks
+    new_x = max(0, x - pad_w)
+    new_y = max(0, y - pad_h)
+    new_w = min(w_img - new_x, w + (2 * pad_w))
+    new_h = min(h_img - new_y, h + (2 * pad_h))
+    
+    return new_x, new_y, new_w, new_h
+
 # ====================================================
-# 2. THE DATABASE LAYER (Backend Only - No UI)
+# 2. THE DATABASE LAYER
 # ====================================================
 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
 
         try:
             self.client = chromadb.PersistentClient(path=db_path)
-            self.collection = self.client.get_or_create_collection(
-                name="face_embeddings",
-                metadata={"hnsw:space": "cosine"}
-            )
+            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:
-                self.faces_dir.mkdir(parents=True, exist_ok=True)
-                logger.info(f"📁 Created {faces_dir} folder. Add images here!")
-                
+            if self.faces_dir.exists(): self._scan_and_index()
+            else: self.faces_dir.mkdir(parents=True, exist_ok=True)
         except Exception as e:
             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()
+        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"))
+            p_id = parts[0] if len(parts) > 1 else "000"
+            p_name = parts[1].replace('_', ' ') if len(parts) > 1 else person_dir.name
             
+            images = list(person_dir.glob("*.*"))
             for img_path in images:
+                if img_path.suffix.lower() not in ['.jpg', '.png', '.webp', '.jpeg']: continue
                 try:
                     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 self.collection.get(ids=[img_hash])['ids']: continue
                     
+                    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],
+                            embeddings=[embedding_objs[0]["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.name}: {e}")
-        
-        if count > 0: 
-            logger.info(f"📥 Added {count} new faces to database.")
-        else:
-            logger.info("ℹ️ Database is up to date.")
+                    logger.error(f"⚠️ Skip {img_path.name}: {e}")
 
     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
+        default = {"match": False, "name": "Unknown", "id": "Unknown", "color": (255, 0, 0)} # Red
+        if not self.is_active or self.collection.count() == 0: return default
 
         try:
-            # Create temp file for DeepFace (it prefers paths)
+            # DeepFace expects BGR or Path. Convert RGB->BGR just in case.
+            # Using a temp file ensures DeepFace preprocessing runs consistently.
             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
-            )
+            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
-            )
-
+            results = self.collection.query(query_embeddings=[embedding_objs[0]["embedding"]], 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:
+            # --- SECURITY FIX: STRICT THRESHOLD ---
+            if distance < RECOGNITION_THRESHOLD:
                 return {
                     "match": True,
                     "name": metadata['name'],
                     "id": metadata['id'],
-                    "color": (0, 255, 0) # Green for match
+                    "color": (0, 255, 0) # Green
                 }
             return default
 
         except Exception as e:
-            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)"
+        return f"✅ Active | {self.collection.count()} Faces" if (self.is_active and self.collection) else "❌ Offline"
 
-# Singleton DB
 FACE_DB = FaceDatabase()
 
 # ====================================================
-# 3. THE UNIFIED DETECTOR (YOLO)
+# 3. DETECTOR & DRAWING LOGIC
 # ====================================================
 class Detector:
     def __init__(self):
-        logger.info("📦 Loading YOLOv8-Face...")
-        try:
-            self.model = YOLO("yolov8n-face.pt")
-            logger.info("✅ Model Loaded.")
-        except Exception as e:
-            logger.error(f"❌ Model Load Failed: {e}")
-            raise e
+        self.model = YOLO("yolov8n-face.pt")
     
     def detect(self, image: np.ndarray):
-        # Uses Hardcoded High Sensitivity
-        results = self.model(image, conf=CONFIDENCE_THRESHOLD, verbose=False)
+        results = self.model(image, conf=DETECTION_CONFIDENCE, 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])
-                faces.append({
-                    "box": (x1, y1, x2-x1, y2-y1),
-                    "conf": float(box.conf[0])
-                })
+                faces.append((x1, y1, x2-x1, y2-y1)) # Return as X, Y, W, H
         return faces
 
 GLOBAL_DETECTOR = Detector()
 
-# ====================================================
-# 4. CORE LOGIC
-# ====================================================
-
 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)
+    # Adaptive Grid Logic
+    grid_pixel_limit = max(1, w // MIN_PIXEL_SIZE)
+    final_grid_size = max(2, min(TARGET_MOSAIC_GRID, grid_pixel_limit))
     
+    # Blur
+    small = cv2.resize(roi, (final_grid_size, final_grid_size), interpolation=cv2.INTER_LINEAR)
+    pixelated = cv2.resize(small, (w, h), interpolation=cv2.INTER_NEAREST)
     image[y:y+h, x:x+w] = pixelated
     return image
 
-def draw_label(image, x, y, w, h, text, color):
+def draw_smart_label(image, x, y, w, h, text, color):
     """
-    1. Always draw the border (The primary signal).
-    2. Attempt to draw text inside.
-    3. If text doesn't fit geometrically, hide it automatically.
+    UX FIX: Draws the label OUTSIDE the face box.
     """
-    # 1. Dynamic Border Thickness
-    # Big face = 2px border, Tiny face = 1px border (so it doesn't look like a blob)
-    thickness = 2 if w > 40 else 1
+    # 1. Draw the Bounding Box
+    thickness = 2
     cv2.rectangle(image, (x, y), (x+w, y+h), color, thickness)
 
-    # 2. Geometry Check: Can we fit text?
-    # We define a 'Minimum Readable Font' (Scale 0.4 is the smallest legible size)
-    min_font_scale = 0.4
+    # 2. Prepare Text
     font = cv2.FONT_HERSHEY_SIMPLEX
-    font_thickness = 1
+    font_scale = 0.6 # Slightly larger for readability
+    font_thick = 2
+    (tw, th), baseline = cv2.getTextSize(text, font, font_scale, font_thick)
+
+    # 3. Smart Positioning (Top vs Bottom)
+    # Default to TOP. If face is at y=0, flip to BOTTOM.
+    text_y = y - 10 
+    if y - th - 15 < 0: 
+        text_y = y + h + th + 10
+
+    # 4. Draw Background Box (Header Style)
+    # Center the text horizontally relative to the face box
+    center_x = x + (w // 2)
+    text_x = center_x - (tw // 2)
     
-    (tw, th), _ = cv2.getTextSize(text, font, min_font_scale, font_thickness)
-    
-    # PADDING: We need at least 2 pixels on sides
-    required_width = tw + 4
-    
-    # THE RULE: If the text is wider than the face, DO NOT DRAW IT.
-    if required_width > w:
-        return 
-
-    # 3. If we passed the check, draw it centered
-    center_x = x + (w // 2) - (tw // 2)
-    center_y = y + (h // 2) + (th // 2)
-
-    # Background Strip (for readability against blur)
-    bg_tl = (center_x - 2, center_y - th - 2)
-    bg_br = (center_x + tw + 2, center_y + 2)
-    cv2.rectangle(image, bg_tl, bg_br, color, -1)
+    # Background rectangle for text
+    pad = 5
+    cv2.rectangle(image, 
+                 (text_x - pad, text_y - th - pad), 
+                 (text_x + tw + pad, text_y + pad), 
+                 color, -1) # Filled
 
-    # Text
-    cv2.putText(image, text, (center_x, center_y), font, min_font_scale, (255, 255, 255), font_thickness, cv2.LINE_AA)
-    
+    # 5. Draw Text
+    cv2.putText(image, text, (text_x, text_y), font, font_scale, (255, 255, 255), font_thick, cv2.LINE_AA)
 
 def process_frame(image, mode):
-    """
-    MASTER FUNCTION (Standardized).
-    """
     if image is None: return None, "No Image"
     
-    # 1. Detection
     faces = GLOBAL_DETECTOR.detect(image)
     processed_img = image.copy()
     log_entries = []
-    labels_to_draw = []
     
-    # =================================================
-    # PASS 1: BLUR & ANALYZE
-    # =================================================
-    for i, face in enumerate(faces):
-        x, y, w, h = face['box']
-        
-        # Default: Unknown/Red
-        full_log_text = "Unknown"
-        img_label_text = "Unknown"
-        color = (255, 0, 0) 
+    # Queue for drawing so labels appear ON TOP of blur
+    draw_queue = [] 
+
+    for i, (raw_x, raw_y, raw_w, raw_h) in enumerate(faces):
         
+        # --- STEP 1: CALCULATE UNIFIED COORDINATES ---
+        # We use these padded coordinates for EVERYTHING (Crop, Blur, Box)
+        # This prevents the "Bleeding" visual glitch.
+        px, py, pw, ph = get_padded_coords(processed_img, raw_x, raw_y, raw_w, raw_h)
+
+        # Defaults
+        label_text = "Unknown"
+        box_color = (200, 0, 0) # Dark Red default
+        log_text = "Unknown"
+
+        # --- STEP 2: RECOGNITION (Data/Smart Mode) ---
         if mode in ["data", "smart"]:
-            face_crop = image[y:y+h, x:x+w]
+            # Crop using the PADDED area to give the model more context (hair, chin)
+            face_crop = processed_img[py:py+ph, px:px+pw]
+            
             if face_crop.size > 0:
                 res = FACE_DB.recognize(face_crop)
-                
                 if res['match']:
-                    # Match: Green
-                    full_log_text = f"MATCH - {res['name']} (ID: {res['id']})"
-                    log_entries.append(f"✅ Face #{i+1}: {full_log_text}")
-                    img_label_text = f"ID: {res['id']}"
-                    color = (0, 255, 0)
+                    label_text = f"{res['name']} ({res['id']})"
+                    box_color = (0, 200, 0) # Green
+                    log_text = f"MATCH: {res['name']}"
                 else:
-                    # No Match: Red
-                    full_log_text = "UNKNOWN"
-                    log_entries.append(f"⚠️ Face #{i+1}: {full_log_text}")
-                    img_label_text = "Unknown"
-                    color = (255, 0, 0)
-        else:
-             log_entries.append(f"🔒 Face #{i+1}: Anonymized")
-
-        # Action: Blur
-        if mode == "privacy" or mode == "smart":
-            processed_img = apply_blur(processed_img, x, y, w, h)
-            
-        # Action: Queue Badge
-        if mode == "data" or mode == "smart":
-            labels_to_draw.append({
-                "x": x, "y": y, "w": w, "h": h, 
-                "text": img_label_text, "color": color
-            })
-
-    # =================================================
-    # PASS 2: DRAW BADGES (Top Layer)
-    # =================================================
-    for item in labels_to_draw:
-        draw_label(processed_img, item['x'], item['y'], item['w'], item['h'], item['text'], item['color'])
-
-    # Create Log
-    if not log_entries:
-        final_log = "No faces detected."
-    else:
-        final_log = "--- Detection Report ---\n" + "\n".join(log_entries)
+                    log_text = "Unknown Person"
+
+            draw_queue.append((px, py, pw, ph, label_text, box_color))
+            log_entries.append(f"Face #{i+1}: {log_text}")
 
+        # --- STEP 3: PRIVACY (Privacy/Smart Mode) ---
+        if mode in ["privacy", "smart"]:
+            processed_img = apply_blur(processed_img, px, py, pw, ph)
+            if mode == "privacy":
+                log_entries.append(f"Face #{i+1}: Redacted")
+
+    # --- STEP 4: DRAW UI (Last Layer) ---
+    for (dx, dy, dw, dh, txt, col) in draw_queue:
+        draw_smart_label(processed_img, dx, dy, dw, dh, txt, col)
+
+    final_log = "--- Report ---\n" + "\n".join(log_entries) if log_entries else "No faces."
     return processed_img, final_log
-    
 
 # ====================================================
-# 5. VIDEO PROCESSING HELPERS
+# 4. VIDEO & GRADIO SETUP
 # ====================================================
-def process_video_general(video_path, mode, progress=gr.Progress()):
-    """Generic video processor."""
+def process_video(video_path, mode, progress=gr.Progress()):
     if not video_path: return None
-    
     cap = cv2.VideoCapture(video_path)
-    if not cap.isOpened(): return None
-
-    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))
+    fps = cap.get(cv2.CAP_PROP_FPS)
+    width, height = int(cap.get(3)), int(cap.get(4))
     
     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))
+    out = cv2.VideoWriter(out_path, cv2.VideoWriter_fourcc(*'mp4v'), fps, (width, height))
     
+    total = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
     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}")
+        if cnt % 10 == 0: progress(cnt/total)
         
     cap.release()
     out.release()
     return out_path
 
-# ====================================================
-# 6. GRADIO INTERFACE
-# ====================================================
-
-with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue"), title="Smart Redaction Demo") as demo:
+with gr.Blocks(theme=gr.themes.Soft(), title="Secure Redaction V2") as demo:
+    gr.Markdown("# 🛡️ Smart Redaction System (Patched V2)")
+    gr.Markdown(f"**Engine Status:** {FACE_DB.get_stats()} | **Security Threshold:** {RECOGNITION_THRESHOLD}")
     
-    gr.Markdown("# 🛡️ Smart Redaction System")
-    gr.Markdown("### From Raw Privacy to Intelligent Security")
-    
-    # Unified Config Info Row
-    with gr.Row():
-        gr.Markdown(f"**System Status:** {FACE_DB.get_stats()}")
-
     with gr.Tabs():
-        
-        # --- TAB 1: RAW PRIVACY ---
-        with gr.TabItem("1️⃣ Raw Privacy (Baseline)"):
-            gr.Markdown("### 🔒 Total Anonymization")
-            gr.Markdown("*GDPR Compliance: Everyone is hidden. No data is extracted.*")
-            
-            with gr.Tabs():
-                with gr.TabItem("Image"):
-                    p_img_in = gr.Image(label="Input", type="numpy", height=400)
-                    p_img_out = gr.Image(label="Anonymized Output", height=400)
-                    p_btn = gr.Button("Apply Privacy", variant="primary")
-                    
-                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("*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("*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
-    # =========================================
-    
-    # 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)
+        with gr.Tab("1️⃣ Raw Privacy"):
+            with gr.Row():
+                p_in = gr.Image(label="Input", type="numpy")
+                p_out = gr.Image(label="Redacted Output")
+            p_btn = gr.Button("Anonymize", variant="primary")
+            p_btn.click(lambda x: process_frame(x, "privacy")[0], p_in, p_out)
+
+        with gr.Tab("2️⃣ Security Data"):
+            with gr.Row():
+                d_in = gr.Image(label="Input", type="numpy")
+                with gr.Column():
+                    d_out = gr.Image(label="Analyst View (Clear Face)")
+                    d_log = gr.Textbox(label="Logs")
+            d_btn = gr.Button("Analyze", variant="primary")
+            d_btn.click(lambda x: process_frame(x, "data"), d_in, [d_out, d_log])
+
+        with gr.Tab("3️⃣ Smart Mode"):
+            with gr.Row():
+                s_in = gr.Image(label="Input", type="numpy")
+                with gr.Column():
+                    s_out = gr.Image(label="Smart Output (Blurred + ID)")
+                    s_log = gr.Textbox(label="Logs")
+            s_btn = gr.Button("Execute Smart Redaction", variant="primary")
+            s_btn.click(lambda x: process_frame(x, "smart"), s_in, [s_out, s_log])
 
 if __name__ == "__main__":
-    try:
-        if GLOBAL_DETECTOR:
-            logger.info("✅ System Ready. Launching...")
-        demo.launch()
-    except Exception as e:
-        logger.error(f"Startup Failed: {e}")
+    demo.launch()