Update app.py

app.py

@@ -44,6 +44,19 @@ 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:
+    """Converts user-friendly sensitivity text to numerical confidence threshold."""
+    return SENSITIVITY_MAP.get(sensitivity, 0.5)
+
 # ====================================================
 # CONFIGURATION DATA CLASSES
 # ====================================================
@@ -91,11 +104,11 @@ 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
+        if face_roi.size == 0: 
+            return image
 
         if self.config.adaptive_blur:
             min_dim = min(w, h)
-            # Intensity now directly maps to kernel size percentage
             kernel_val = int(min_dim * (self.config.intensity / 100.0))
             kernel_val = max(self.config.min_kernel, min(kernel_val, self.config.max_kernel))
         else:
@@ -111,11 +124,13 @@ 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
+        if face_roi.size == 0: 
+            return image
 
         h_roi, w_roi = face_roi.shape[:2]
         pixel_size = self.config.pixel_size
-        if pixel_size <= 0: return image
+        if pixel_size <= 0: 
+            return image
 
         small = cv2.resize(face_roi, (max(1, w_roi // pixel_size), max(1, h_roi // pixel_size)), interpolation=cv2.INTER_LINEAR)
         pixelated = cv2.resize(small, (w_roi, h_roi), interpolation=cv2.INTER_NEAREST)
@@ -133,7 +148,8 @@ def get_blur_effect(config: BlurConfig) -> BlurEffect:
     """Factory function to create a blur effect instance."""
     blur_effects = {"gaussian": GaussianBlur, "pixelate": PixelateBlur, "solid": SolidColorBlur}
     blur_class = blur_effects.get(config.type)
-    if not blur_class: raise ValueError(f"Unknown blur type: {config.type}")
+    if not blur_class: 
+        raise ValueError(f"Unknown blur type: {config.type}")
     return blur_class(config)
 
 # ====================================================
@@ -158,20 +174,27 @@ class YOLOv8FaceDetector:
         annotated_image = image.copy() if return_annotated 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])
                 faces.append({"x": x1, "y": y1, "width": x2 - x1, "height": y2 - y1, "confidence": confidence})
+                
                 if return_annotated:
+                    # Draw bounding box
                     cv2.rectangle(annotated_image, (x1, y1), (x2, y2), (0, 255, 0), 3)
-                    label = f"Face: {confidence:.2%}"
+                    
+                    # Simplified label - just "Face" without percentage
+                    label = "Face"
                     (w, h), _ = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, 0.6, 2)
                     cv2.rectangle(annotated_image, (x1, y1 - h - 10), (x1 + w, y1), (0, 255, 0), -1)
                     cv2.putText(annotated_image, label, (x1, y1 - 5), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 0), 2)
+        
         return faces, annotated_image
 
 GLOBAL_DETECTOR: Optional[YOLOv8FaceDetector] = None
+
 def get_global_detector() -> YOLOv8FaceDetector:
     """Initializes and returns the global singleton detector instance."""
     global GLOBAL_DETECTOR
@@ -222,9 +245,13 @@ def get_app_instance(blur_type: str, blur_amount: float, blur_size: float) -> Fa
     )
     return FacePrivacyApp(app_config, detector)
 
-def process_media(media, blur_type, blur_amount, blur_size, confidence):
-    if media is None: return None
+def process_media(media, blur_type, blur_amount, blur_size, sensitivity):
+    """Process single image with blur effect."""
+    if media is None: 
+        return None
     try:
+        # Convert sensitivity to confidence threshold
+        confidence = get_confidence_from_sensitivity(sensitivity)
         app = get_app_instance(blur_type, blur_amount, blur_size)
         return app.process_image(media, confidence)
     except Exception as e:
@@ -232,18 +259,24 @@ def process_media(media, blur_type, blur_amount, blur_size, confidence):
         gr.Warning(f"An error occurred: {e}")
         return media
 
-def process_video(video_file, blur_type, blur_amount, blur_size, confidence, progress=gr.Progress()):
-    if video_file is None: return None, "⚠️ No video provided."
+def process_video(video_file, blur_type, blur_amount, blur_size, sensitivity, progress=gr.Progress()):
+    """Process video with blur effect."""
+    if video_file is None: 
+        return None, "⚠️ No video provided."
     try:
+        # Convert sensitivity to confidence threshold
+        confidence = get_confidence_from_sensitivity(sensitivity)
         app = get_app_instance(blur_type, blur_amount, blur_size)
         cap = cv2.VideoCapture(video_file.name)
-        if not cap.isOpened(): return None, "❌ Cannot open video file."
+        if not cap.isOpened(): 
+            return None, "❌ Cannot open video file."
 
         out_path = create_temp_file()
-        fourcc = cv2.VideoWriter_fourcc(*'avc1') # H.264 for browser compatibility
+        fourcc = cv2.VideoWriter_fourcc(*'avc1')
         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))
+        
         if not out_vid.isOpened():
             logger.warning("H.264 codec failed, falling back to mp4v.")
             out_vid = cv2.VideoWriter(out_path, cv2.VideoWriter_fourcc(*'mp4v'), fps, (w, h))
@@ -251,11 +284,13 @@ def process_video(video_file, blur_type, blur_amount, blur_size, confidence, pro
         frame_num = 0
         while cap.isOpened():
             ret, frame = cap.read()
-            if not ret: break
+            if not ret: 
+                break
             frame_num += 1
             progress(frame_num / max(total_frames, 1), desc=f"Processing frame {frame_num}/{total_frames}")
             processed_frame = app.process_image(frame, confidence)
             out_vid.write(processed_frame)
+        
         cap.release()
         out_vid.release()
         return out_path, f"✅ Processed {frame_num} frames."
@@ -264,65 +299,83 @@ def process_video(video_file, blur_type, blur_amount, blur_size, confidence, pro
         gr.Error(f"Video processing failed: {e}")
         return None, f"❌ Error: {e}"
 
-def detect_faces_image(image, confidence):
-    if image is None: return None, "⚠️ No image provided."
+def detect_faces_image(image, sensitivity):
+    """Detect faces in single image."""
+    if image is None: 
+        return None, "⚠️ No image provided."
     try:
+        # Convert sensitivity to confidence threshold
+        confidence = get_confidence_from_sensitivity(sensitivity)
         detector = get_global_detector()
         faces, annotated_image = detector.detect_faces(image, confidence, return_annotated=True)
+        
+        # Simplified result - just show count
         if faces:
-            result = f"✅ **{len(faces)} face(s) detected!**\n\n" + "\n".join([f"- Face {i+1}: Confidence {f['confidence']:.2%}" for i, f in enumerate(faces)])
+            result = f"✅ **{len(faces)} face(s) detected!**"
         else:
             result = "❌ **No faces detected.**"
+        
         return annotated_image, result
     except Exception as e:
         logger.error(f"Image detection error: {e}")
         gr.Warning(f"An error occurred: {e}")
         return image, f"❌ Error: {e}"
 
-def detect_faces_video(video_file, confidence, progress=gr.Progress()):
-    if video_file is None: return None, "⚠️ No video provided."
+def detect_faces_video(video_file, sensitivity, progress=gr.Progress()):
+    """Detect faces in video."""
+    if video_file is None: 
+        return None, "⚠️ No video provided."
     try:
+        # Convert sensitivity to confidence threshold
+        confidence = get_confidence_from_sensitivity(sensitivity)
         detector = get_global_detector()
         cap = cv2.VideoCapture(video_file.name)
-        if not cap.isOpened(): return None, "❌ Cannot open video file."
+        if not cap.isOpened(): 
+            return None, "❌ Cannot open video file."
 
         out_path = create_temp_file()
         fourcc = cv2.VideoWriter_fourcc(*'avc1')
         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))
-        if not out_vid.isOpened(): out_vid = cv2.VideoWriter(out_path, cv2.VideoWriter_fourcc(*'mp4v'), fps, (w,h))
+        out_vid = cv2.VideoWriter(out_path, fourcc, fps, (w, h))
+        
+        if not out_vid.isOpened(): 
+            out_vid = cv2.VideoWriter(out_path, cv2.VideoWriter_fourcc(*'mp4v'), fps, (w, h))
 
-        frame_num, frames_with_faces, all_confidences = 0, 0, []
+        frame_num, frames_with_faces = 0, 0
         while cap.isOpened():
             ret, frame = cap.read()
-            if not ret: break
+            if not ret: 
+                break
             frame_num += 1
             progress(frame_num / max(total_frames, 1), desc=f"Analyzing frame {frame_num}/{total_frames}")
             faces, annotated_frame = detector.detect_faces(frame, confidence, return_annotated=True)
             if faces:
                 frames_with_faces += 1
-                all_confidences.extend([f["confidence"] for f in faces])
             out_vid.write(annotated_frame)
+        
         cap.release()
         out_vid.release()
         
+        # Simplified result - just show frame count
         if frames_with_faces > 0:
-            avg_conf = sum(all_confidences) / len(all_confidences)
-            result = (f"✅ **Faces detected in {frames_with_faces}/{frame_num} frames!**\n"
-                      f"📈 Average Confidence: **{avg_conf:.2%}**\n"
-                      f"🎯 Max Confidence: **{max(all_confidences):.2%}**")
+            result = f"✅ **Faces detected in {frames_with_faces}/{frame_num} frames!**"
         else:
             result = f"❌ **No faces detected in {frame_num} frames.**"
+        
         return out_path, result
     except Exception as e:
         logger.error(f"Video detection error: {e}")
         gr.Error(f"Video detection failed: {e}")
         return None, f"❌ Error: {e}"
 
-def detect_faces_webcam(image, confidence):
-    if image is None: return None
+def detect_faces_webcam(image, sensitivity):
+    """Detect faces in webcam stream."""
+    if image is None: 
+        return None
     try:
+        # Convert sensitivity to confidence threshold
+        confidence = get_confidence_from_sensitivity(sensitivity)
         detector = get_global_detector()
         _, annotated_image = detector.detect_faces(image, confidence, return_annotated=True)
         return annotated_image
@@ -335,105 +388,227 @@ def detect_faces_webcam(image, confidence):
 # ====================================================
 with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue"), title="Face Privacy Tool") as demo:
     gr.Markdown("# 🔐 Face Privacy Tool")
-    gr.Markdown("AI-powered face detection and privacy protection using **YOLOv8-Face**. Obscure faces in images, videos, and live webcam feeds, or use the detection mode to verify their presence.")
+    gr.Markdown("AI-powered face detection and privacy protection using YOLOv8-Face. Obscure faces in images, videos, and live webcam feeds, or use the detection mode to verify their presence.")
 
     with gr.Row():
+        # ========== SETTINGS SIDEBAR (WRAPPED IN FRAME) ==========
         with gr.Column(scale=1):
-            gr.Markdown("### ⚙️ Global Settings")
-            with gr.Accordion("Privacy Settings", open=True):
-                blur_type = gr.Radio(["gaussian", "pixelate", "solid"], value="pixelate", label="Blur Type", info="Choose how to obscure faces.")
-                blur_amount = gr.Slider(1, 100, step=1, value=25, label="Blur Intensity/Size", info="Higher = more obscured.")
-                blur_size = gr.Slider(1.0, 2.0, step=0.05, value=1.2, label="Coverage Area", info="Expand blur beyond face boundary.")
-            with gr.Accordion("Detection Settings", open=True):
-                detection_confidence = gr.Slider(0.1, 0.9, step=0.05, value=0.5, label="Detection Threshold", info="Lower = more sensitive, but more false positives.")
-
+            with gr.Frame():
+                gr.Markdown("### ⚙️ Global Settings")
+                
+                with gr.Accordion("Privacy Settings", open=True):
+                    blur_type = gr.Radio(
+                        ["gaussian", "pixelate", "solid"], 
+                        value="pixelate", 
+                        label="Blur Type", 
+                        info="Choose how to obscure faces."
+                    )
+                    blur_amount = gr.Slider(
+                        1, 100, 
+                        step=1, 
+                        value=25, 
+                        label="Blur Intensity/Size", 
+                        info="Higher = more obscured."
+                    )
+                    blur_size = gr.Slider(
+                        1.0, 2.0, 
+                        step=0.05, 
+                        value=1.2, 
+                        label="Coverage Area", 
+                        info="Expand blur beyond face boundary."
+                    )
+                
+                with gr.Accordion("Detection Settings", open=True):
+                    # Changed from Slider to Radio for sensitivity
+                    detection_sensitivity = gr.Radio(
+                        choices=list(SENSITIVITY_MAP.keys()),
+                        value="Balanced (Default)",
+                        label="Detection Sensitivity",
+                        info="How strict the face detection should be"
+                    )
+
+        # ========== MAIN CONTENT AREA ==========
         with gr.Column(scale=2):
             with gr.Tabs():
+                # ========== PRIVACY MODE ==========
                 with gr.TabItem("🔒 Privacy Mode (Blur Faces)"):
                     gr.Markdown("### Apply privacy protection to your media.")
+                    
                     with gr.Tabs():
+                        # Image Tab
                         with gr.TabItem("📷 Image"):
                             with gr.Row():
-                                img_in_blur = gr.Image(sources=["upload", "clipboard"], type="numpy", label="Input Image")
-                                img_out_blur = gr.Image(type="numpy", label="Protected Image")
+                                img_in_blur = gr.Image(
+                                    sources=["upload", "clipboard"], 
+                                    type="numpy", 
+                                    label="Input Image",
+                                    height=500,
+                                    object_fit="contain"
+                                )
+                                img_out_blur = gr.Image(
+                                    type="numpy", 
+                                    label="Protected Image",
+                                    height=500,
+                                    object_fit="contain"
+                                )
                             with gr.Row():
                                 blur_img_btn = gr.Button("Apply Privacy Blur", variant="primary", scale=3)
                                 gr.ClearButton([img_in_blur, img_out_blur], scale=1)
                             gr.Examples(
                                 examples=[
                                     ["./examples/single_face.jpg"],
-                                    ["./examples/two_faces.jpg"],
-                                    ["./examples/group_photo.jpg"],
+                                    ["./examples/two_faces.png"],
+                                    ["./examples/group_photo.png"],
+                                    ["./examples/group2.webp"],
                                 ],
                                 inputs=img_in_blur,
                                 label="Click an example to try"
-                            )                            
+                            )
+                        
+                        # Video Tab
                         with gr.TabItem("🎥 Video"):
                             with gr.Row():
-                                vid_in_blur = gr.File(file_types=[".mp4", ".mov", ".avi"], label="Input Video")
+                                vid_in_blur = gr.File(
+                                    file_types=[".mp4", ".mov", ".avi"], 
+                                    label="Input Video"
+                                )
                                 with gr.Column():
-                                    vid_out_blur = gr.Video(label="Protected Video")
+                                    vid_out_blur = gr.Video(
+                                        label="Protected Video",
+                                        height=500
+                                    )
                                     vid_status_blur = gr.Markdown("")
                             with gr.Row():
                                 blur_vid_btn = gr.Button("Process Video", variant="primary", scale=3)
                                 gr.ClearButton([vid_in_blur, vid_out_blur, vid_status_blur], scale=1)
 
+                        # Webcam Tab
                         with gr.TabItem("📹 Webcam"):
                             gr.Markdown("**Real-time privacy protection from your webcam feed.**")
                             with gr.Row():
-                                web_in_blur = gr.Image(sources=["webcam"], type="numpy", streaming=True, label="Live Webcam")
-                                web_out_blur = gr.Image(type="numpy", label="Protected Feed")
-
+                                web_in_blur = gr.Image(
+                                    sources=["webcam"], 
+                                    type="numpy", 
+                                    streaming=True, 
+                                    label="Live Webcam",
+                                    height=500,
+                                    object_fit="contain"
+                                )
+                                web_out_blur = gr.Image(
+                                    type="numpy", 
+                                    label="Protected Feed",
+                                    height=500,
+                                    object_fit="contain"
+                                )
+
+                # ========== DETECTION MODE ==========
                 with gr.TabItem("🔍 Detection Mode (Check for Faces)"):
                     gr.Markdown("### Verify if your media contains human faces.")
+                    
                     with gr.Tabs():
+                        # Image Detection Tab
                         with gr.TabItem("📷 Image"):
                             with gr.Row():
-                                img_in_detect = gr.Image(sources=["upload", "clipboard"], type="numpy", label="Input Image", height=480)
+                                img_in_detect = gr.Image(
+                                    sources=["upload", "clipboard"], 
+                                    type="numpy", 
+                                    label="Input Image", 
+                                    height=500,
+                                    object_fit="contain"
+                                )
                                 with gr.Column():
-                                    img_out_detect = gr.Image(type="numpy", label="Detection Result", height=480)
+                                    img_out_detect = gr.Image(
+                                        type="numpy", 
+                                        label="Detection Result", 
+                                        height=500,
+                                        object_fit="contain"
+                                    )
                                     img_status_detect = gr.Markdown("_Upload an image to start._")
-                
+                            
                             with gr.Row():
                                 detect_img_btn = gr.Button("Detect Faces", variant="primary", scale=3)
                                 gr.ClearButton([img_in_detect, img_out_detect, img_status_detect], scale=1)
                             gr.Examples(
                                 examples=[
                                     ["./examples/single_face.jpg"],
-                                    ["./examples/two_faces.jpg"],
-                                    ["./examples/group_photo.jpg"],
+                                    ["./examples/two_faces.png"],
+                                    ["./examples/group_photo.png"],
+                                    ["./examples/group2.webp"]
                                 ],
                                 inputs=img_in_detect,
                                 label="Click an example to try"
                             )
 
+                        # Video Detection Tab
                         with gr.TabItem("🎥 Video"):
                             with gr.Row():
-                                vid_in_detect = gr.File(file_types=[".mp4", ".mov", ".avi"], label="Input Video")
+                                vid_in_detect = gr.File(
+                                    file_types=[".mp4", ".mov", ".avi"], 
+                                    label="Input Video"
+                                )
                                 with gr.Column():
-                                    vid_out_detect = gr.Video(label="Annotated Video")
+                                    vid_out_detect = gr.Video(
+                                        label="Annotated Video",
+                                        height=500
+                                    )
                                     vid_status_detect = gr.Markdown("_Upload a video to start._")
                             with gr.Row():
                                 detect_vid_btn = gr.Button("Analyze Video for Faces", variant="primary", scale=3)
                                 gr.ClearButton([vid_in_detect, vid_out_detect, vid_status_detect], scale=1)
 
+                        # Webcam Detection Tab
                         with gr.TabItem("📹 Webcam"):
                             gr.Markdown("**Live face detection from your webcam feed.**")
                             with gr.Row():
-                                web_in_detect = gr.Image(sources=["webcam"], type="numpy", streaming=True, label="Live Feed")
-                                web_out_detect = gr.Image(type="numpy", label="Detection Result")
-
-    # --- Event Handlers ---
-    # Privacy Mode
-    blur_img_btn.click(process_media, inputs=[img_in_blur, blur_type, blur_amount, blur_size, detection_confidence], outputs=img_out_blur)
-    blur_vid_btn.click(process_video, inputs=[vid_in_blur, blur_type, blur_amount, blur_size, detection_confidence], outputs=[vid_out_blur, vid_status_blur])
-    web_in_blur.stream(process_media, inputs=[web_in_blur, blur_type, blur_amount, blur_size, detection_confidence], outputs=web_out_blur)
-    
-    # Detection Mode
-    detect_img_btn.click(detect_faces_image, inputs=[img_in_detect, detection_confidence], outputs=[img_out_detect, img_status_detect])
-    detect_vid_btn.click(detect_faces_video, inputs=[vid_in_detect, detection_confidence], outputs=[vid_out_detect, vid_status_detect])
-    web_in_detect.stream(detect_faces_webcam, inputs=[web_in_detect, detection_confidence], outputs=web_out_detect)
+                                web_in_detect = gr.Image(
+                                    sources=["webcam"], 
+                                    type="numpy", 
+                                    streaming=True, 
+                                    label="Live Feed",
+                                    height=500,
+                                    object_fit="contain"
+                                )
+                                web_out_detect = gr.Image(
+                                    type="numpy", 
+                                    label="Detection Result",
+                                    height=500,
+                                    object_fit="contain"
+                                )
+
+    # ========== EVENT HANDLERS ==========
+    # Privacy Mode (updated to use detection_sensitivity instead of detection_confidence)
+    blur_img_btn.click(
+        process_media, 
+        inputs=[img_in_blur, blur_type, blur_amount, blur_size, detection_sensitivity], 
+        outputs=img_out_blur
+    )
+    blur_vid_btn.click(
+        process_video, 
+        inputs=[vid_in_blur, blur_type, blur_amount, blur_size, detection_sensitivity], 
+        outputs=[vid_out_blur, vid_status_blur]
+    )
+    web_in_blur.stream(
+        process_media, 
+        inputs=[web_in_blur, blur_type, blur_amount, blur_size, detection_sensitivity], 
+        outputs=web_out_blur
+    )
 
+    # Detection Mode (updated to use detection_sensitivity instead of detection_confidence)
+    detect_img_btn.click(
+        detect_faces_image, 
+        inputs=[img_in_detect, detection_sensitivity], 
+        outputs=[img_out_detect, img_status_detect]
+    )
+    detect_vid_btn.click(
+        detect_faces_video, 
+        inputs=[vid_in_detect, detection_sensitivity], 
+        outputs=[vid_out_detect, vid_status_detect]
+    )
+    web_in_detect.stream(
+        detect_faces_webcam, 
+        inputs=[web_in_detect, detection_sensitivity], 
+        outputs=web_out_detect
+    )
 
 # ====================================================
 # MAIN ENTRY POINT
@@ -446,4 +621,5 @@ if __name__ == "__main__":
         demo.launch()
     except Exception as e:
         logger.error(f"❌ Startup failed: {e}")
-        logger.info("💡 Make sure 'yolov8n-face.pt' is available in the current directory or will be downloaded automatically by ultralytics.")
+        logger.info("💡 Make sure 'yolov8n-face.pt' is available in the current directory or will be downloaded automatically by ultralytics.")
+