Update app.py

app.py

@@ -4,23 +4,45 @@ import atexit
 import tempfile
 import os
 import hashlib
+import shutil
 from dataclasses import dataclass
 from typing import Any, Dict, List, Tuple, Optional
 from pathlib import Path
 
+# ==========================================
+# 🚀 FAST STARTUP: LOCAL WEIGHTS SETUP
+# ==========================================
+def setup_local_weights():
+    os.environ["DEEPFACE_HOME"] = os.getcwd()
+    target_dir = os.path.join(os.getcwd(), ".deepface", "weights")
+    os.makedirs(target_dir, exist_ok=True)
+    weight_file = "facenet512_weights.h5"
+    target_path = os.path.join(target_dir, weight_file)
+
+    if os.path.exists(weight_file) and not os.path.exists(target_path):
+        print(f"📦 Found local weights: {weight_file}. Installing...")
+        shutil.copy(weight_file, target_path) # Use copy so original stays visible in files
+    elif os.path.exists(target_path):
+        print("✅ Weights already installed.")
+    else:
+        print("⚠️ Local weights not found. DeepFace might download them.")
+
+# RUN THIS IMMEDIATELY BEFORE IMPORTS
+setup_local_weights()
+
 # --- Computer Vision & UI Libraries ---
 import cv2
 import numpy as np
 import gradio as gr
 from ultralytics import YOLO
 
-# --- Face Recognition Libraries (Optional / Fallback) ---
+# --- Face Recognition Libraries ---
 try:
     from deepface import DeepFace
     DEEPFACE_AVAILABLE = True
 except ImportError:
     DEEPFACE_AVAILABLE = False
-    logging.warning("⚠️ DeepFace not installed - Recognition will be disabled (Fallback Mode).")
+    logging.warning("⚠️ DeepFace not installed - Recognition disabled.")
 
 try:
     import chromadb
@@ -38,18 +60,11 @@ logger = logging.getLogger(__name__)
 # ====================================================
 
 # --- 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)
+DETECTION_CONFIDENCE = 0.4   # Moderate strictness to reduce false boxes
+RECOGNITION_THRESHOLD = 0.30 # STRICT: Prevents Identity Confusion
+TARGET_MOSAIC_GRID = 10      # Pixelation Grid Size
+MIN_PIXEL_SIZE = 12          # Min block size (prevents weak blur on small faces)
+COVERAGE_SCALE = 1.2         # 120% padding (Captures hair/chin)
 
 TEMP_FILES = []
 
@@ -72,12 +87,9 @@ def get_padded_coords(image, x, y, w, h, scale=COVERAGE_SCALE):
     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))
@@ -101,8 +113,12 @@ class FaceDatabase:
             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
-            if self.faces_dir.exists(): self._scan_and_index()
-            else: self.faces_dir.mkdir(parents=True, exist_ok=True)
+            
+            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}")
 
@@ -123,9 +139,14 @@ class FaceDatabase:
                 if img_path.suffix.lower() not in ['.jpg', '.png', '.webp', '.jpeg']: continue
                 try:
                     img_hash = self._get_hash(img_path)
+                    # Skip if already indexed
                     if self.collection.get(ids=[img_hash])['ids']: continue
                     
-                    embedding_objs = DeepFace.represent(img_path=str(img_path), model_name="Facenet512", enforce_detection=False)
+                    embedding_objs = DeepFace.represent(
+                        img_path=str(img_path), 
+                        model_name="Facenet512", 
+                        enforce_detection=False
+                    )
                     if embedding_objs:
                         self.collection.add(
                             ids=[img_hash],
@@ -141,8 +162,6 @@ class FaceDatabase:
         if not self.is_active or self.collection.count() == 0: return default
 
         try:
-            # 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))
             
@@ -157,7 +176,7 @@ class FaceDatabase:
             distance = results['distances'][0][0]
             metadata = results['metadatas'][0][0]
 
-            # --- SECURITY FIX: STRICT THRESHOLD ---
+            # STRICT THRESHOLD APPLIED HERE
             if distance < RECOGNITION_THRESHOLD:
                 return {
                     "match": True,
@@ -166,7 +185,6 @@ class FaceDatabase:
                     "color": (0, 255, 0) # Green
                 }
             return default
-
         except Exception as e:
             return default
 
@@ -176,10 +194,11 @@ class FaceDatabase:
 FACE_DB = FaceDatabase()
 
 # ====================================================
-# 3. DETECTOR & DRAWING LOGIC
+# 3. DETECTOR & PROCESSING LOGIC
 # ====================================================
 class Detector:
     def __init__(self):
+        # Uses the local pt file if available
         self.model = YOLO("yolov8n-face.pt")
     
     def detect(self, image: np.ndarray):
@@ -189,7 +208,7 @@ class Detector:
             if r.boxes is None: continue
             for box in r.boxes:
                 x1, y1, x2, y2 = map(int, box.xyxy[0])
-                faces.append((x1, y1, x2-x1, y2-y1)) # Return as X, Y, W, H
+                faces.append((x1, y1, x2-x1, y2-y1))
         return faces
 
 GLOBAL_DETECTOR = Detector()
@@ -198,11 +217,9 @@ def apply_blur(image, x, y, w, h):
     roi = image[y:y+h, x:x+w]
     if roi.size == 0: return image
     
-    # 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
@@ -210,146 +227,209 @@ def apply_blur(image, x, y, w, h):
 
 def draw_smart_label(image, x, y, w, h, text, color):
     """
-    UX FIX: Draws the label OUTSIDE the face box.
+    UX FIX: Draws label OUTSIDE the box (Header/Footer style)
     """
-    # 1. Draw the Bounding Box
-    thickness = 2
+    # 1. Draw Box
+    thickness = 2 if w > 40 else 1
     cv2.rectangle(image, (x, y), (x+w, y+h), color, thickness)
 
-    # 2. Prepare Text
+    if not text: return
+
+    # 2. Measure Text
     font = cv2.FONT_HERSHEY_SIMPLEX
-    font_scale = 0.6 # Slightly larger for readability
+    font_scale = 0.6
     font_thick = 2
-    (tw, th), baseline = cv2.getTextSize(text, font, font_scale, font_thick)
+    (tw, th), _ = 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 close to top edge, flip to bottom
     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 horizontally
     center_x = x + (w // 2)
     text_x = center_x - (tw // 2)
     
-    # Background rectangle for text
-    pad = 5
+    # Background Box
+    pad = 4
     cv2.rectangle(image, 
                  (text_x - pad, text_y - th - pad), 
                  (text_x + tw + pad, text_y + pad), 
-                 color, -1) # Filled
+                 color, -1)
 
-    # 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
+    """
     if image is None: return None, "No Image"
     
+    # Detect
     faces = GLOBAL_DETECTOR.detect(image)
     processed_img = image.copy()
     log_entries = []
     
-    # Queue for drawing so labels appear ON TOP of blur
+    # Queue drawing to ensure labels are 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.
+        # 1. UNIFIED COORDINATES (Fixes "Bleeding" Blur)
         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
+        label_text = ""
+        box_color = (200, 0, 0) # Default Red
         log_text = "Unknown"
 
-        # --- STEP 2: RECOGNITION (Data/Smart Mode) ---
+        # 2. ANALYSIS (Data/Smart Mode)
         if mode in ["data", "smart"]:
-            # Crop using the PADDED area to give the model more context (hair, chin)
+            # Crop using padded coords for better context
             face_crop = processed_img[py:py+ph, px:px+pw]
             
             if face_crop.size > 0:
                 res = FACE_DB.recognize(face_crop)
                 if res['match']:
-                    label_text = f"{res['name']} ({res['id']})"
+                    label_text = f"ID: {res['id']}"
                     box_color = (0, 200, 0) # Green
                     log_text = f"MATCH: {res['name']}"
                 else:
+                    label_text = "Unknown"
                     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) ---
+        # 3. MODIFICATION (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) ---
+    # 4. DRAW UI (Top 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."
+    final_log = "--- Detection Report ---\n" + "\n".join(log_entries) if log_entries else "No faces detected."
     return processed_img, final_log
 
 # ====================================================
-# 4. VIDEO & GRADIO SETUP
+# 4. VIDEO PROCESSING
 # ====================================================
-def process_video(video_path, mode, progress=gr.Progress()):
+def process_video_general(video_path, mode, progress=gr.Progress()):
     if not video_path: return None
+    
     cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened(): return None
+
     fps = cap.get(cv2.CAP_PROP_FPS)
-    width, height = int(cap.get(3)), int(cap.get(4))
+    width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    total = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
     
     out_path = create_temp_file()
+    # Try mp4v for better compatibility
     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
+        
         res_frame, _ = process_frame(frame, mode)
         out.write(res_frame)
+        
         cnt += 1
-        if cnt % 10 == 0: progress(cnt/total)
+        if total > 0 and cnt % 5 == 0: 
+            progress(cnt/total, desc=f"Processing Frame {cnt}/{total}")
         
     cap.release()
     out.release()
     return out_path
 
-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}")
+# ====================================================
+# 5. GRADIO INTERFACE (FULL)
+# ====================================================
+with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue"), title="Smart Redaction Pro") as demo:
+    
+    gr.Markdown("# 🛡️ Smart Redaction System (Enterprise Patch)")
+    gr.Markdown(f"**Status:** {FACE_DB.get_stats()} | **Strictness:** {RECOGNITION_THRESHOLD}")
     
     with gr.Tabs():
-        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])
+        
+        # --- TAB 1: RAW PRIVACY ---
+        with gr.TabItem("1️⃣ Raw Privacy"):
+            gr.Markdown("### 🔒 Total Anonymization")
+            with gr.Tabs():
+                with gr.TabItem("Image"):
+                    p_img_in = gr.Image(label="Input", type="numpy", height=400)
+                    p_img_out = gr.Image(label="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="Output Video")
+                    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 Stream")
+
+        # --- TAB 2: DATA LAYER ---
+        with gr.TabItem("2️⃣ Security Data"):
+            gr.Markdown("### 🔍 Recognition (No Blur)")
+            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="Output", height=400)
+                            d_log_out = gr.Textbox(label="Logs", lines=4)
+                    d_btn = gr.Button("Analyze", variant="primary")
+                with gr.TabItem("Video"):
+                    d_vid_in = gr.Video(label="Input Video")
+                    d_vid_out = gr.Video(label="Output Video")
+                    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 Stream")
+
+        # --- TAB 3: SMART REDACTION ---
+        with gr.TabItem("3️⃣ Smart Redaction"):
+            gr.Markdown("### 🛡️ Identity + Privacy")
+            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="Output", height=400)
+                            s_log_out = gr.Textbox(label="Logs", 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="Output Video")
+                    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 Stream")
+
+    # =========================================
+    # WIRING
+    # =========================================
+    
+    # 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)
+
+    # 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)
+
+    # 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)
 
 if __name__ == "__main__":
     demo.launch()