Update app.py

app.py

@@ -12,21 +12,15 @@ from typing import Optional, Dict, List, Tuple
 from dataclasses import dataclass, field
 from collections import Counter
 
-# Gradio
 import gradio as gr
 
-# PyTorch, YOLO, FaceNet, and deep_sort
 from ultralytics import YOLO
 from facenet_pytorch import InceptionResnetV1
 from torchvision import transforms
 from deep_sort_realtime.deepsort_tracker import DeepSort
 
-# Mediapipe for face mesh, iris detection, blink detection, and hand tracking
 import mediapipe as mp
 
-# --------------------------------------------------------------------
-# LOGGING
-# --------------------------------------------------------------------
 logging.basicConfig(
     level=logging.INFO,
     format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
@@ -34,31 +28,22 @@ logging.basicConfig(
 )
 logger = logging.getLogger(__name__)
 
-# Mute debug logs from third-party libraries
 logging.getLogger('torch').setLevel(logging.ERROR)
 logging.getLogger('mediapipe').setLevel(logging.ERROR)
 logging.getLogger('deep_sort_realtime').setLevel(logging.ERROR)
 
-# --------------------------------------------------------------------
-# CONSTANTS
-# --------------------------------------------------------------------
 DEFAULT_MODEL_URL = "https://github.com/wuhplaptop/face-11-n/blob/main/face2.pt?raw=true"
 DEFAULT_DB_PATH = os.path.expanduser("~/.face_pipeline/known_faces.pkl")
 MODEL_DIR = os.path.expanduser("~/.face_pipeline/models")
 CONFIG_PATH = os.path.expanduser("~/.face_pipeline/config.pkl")
 
-# Landmark indices for blink detection
 LEFT_EYE_IDX = [33, 160, 158, 133, 153, 144]
 RIGHT_EYE_IDX = [263, 387, 385, 362, 380, 373]
 
-# Mediapipe references
 mp_drawing = mp.solutions.drawing_utils
 mp_face_mesh = mp.solutions.face_mesh
 mp_hands = mp.solutions.hands
 
-# --------------------------------------------------------------------
-# DATACLASS: PipelineConfig
-# --------------------------------------------------------------------
 @dataclass
 class PipelineConfig:
     detector: Dict = field(default_factory=dict)
@@ -141,9 +126,6 @@ class PipelineConfig:
             logger.error(f"Config load failed: {str(e)}")
             return cls()
 
-# --------------------------------------------------------------------
-# FACE DATABASE
-# --------------------------------------------------------------------
 class FaceDatabase:
     def __init__(self, db_path: str = DEFAULT_DB_PATH):
         self.db_path = db_path
@@ -208,9 +190,6 @@ class FaceDatabase:
                     results.append((lbl, similarity))
         return sorted(results, key=lambda x: x[1], reverse=True)
 
-# --------------------------------------------------------------------
-# YOLO FACE DETECTOR
-# --------------------------------------------------------------------
 class YOLOFaceDetector:
     def __init__(self, model_path: str, device: str = 'cpu'):
         self.model = None
@@ -250,9 +229,6 @@ class YOLOFaceDetector:
             logger.error(f"Detection error: {str(e)}")
             return []
 
-# --------------------------------------------------------------------
-# FACE TRACKER (DeepSort)
-# --------------------------------------------------------------------
 class FaceTracker:
     def __init__(self, max_age: int = 30):
         self.tracker = DeepSort(max_age=max_age, embedder='mobilenet')
@@ -270,9 +246,6 @@ class FaceTracker:
             logger.error(f"Tracking error: {str(e)}")
             return []
 
-# --------------------------------------------------------------------
-# FACENET EMBEDDER
-# --------------------------------------------------------------------
 class FaceNetEmbedder:
     def __init__(self, device: str = 'cpu'):
         self.device = device
@@ -296,9 +269,6 @@ class FaceNetEmbedder:
             logger.error(f"Embedding failed: {str(e)}")
             return None
 
-# --------------------------------------------------------------------
-# BLINK DETECTION
-# --------------------------------------------------------------------
 def detect_blink(face_roi: np.ndarray, threshold: float = 0.25) -> Tuple[bool, float, float, np.ndarray, np.ndarray]:
     """
     Returns:
@@ -341,9 +311,6 @@ def detect_blink(face_roi: np.ndarray, threshold: float = 0.25) -> Tuple[bool, f
         logger.error(f"Blink detection error: {str(e)}")
         return False, 0.0, 0.0, None, None
 
-# --------------------------------------------------------------------
-# FACE MESH + IRIS DETECTION / DRAWING
-# --------------------------------------------------------------------
 def process_face_mesh(face_roi: np.ndarray):
     try:
         fm_proc = mp_face_mesh.FaceMesh(
@@ -391,9 +358,6 @@ def draw_face_mesh(image: np.ndarray, face_landmarks, config: Dict, pipeline_con
             connection_drawing_spec=mp_drawing.DrawingSpec(color=iris_color_bgr, thickness=2)
         )
 
-# --------------------------------------------------------------------
-# EYE COLOR DETECTION
-# --------------------------------------------------------------------
 EYE_COLOR_RANGES = {
     "amber": (255, 191, 0),
     "blue": (0, 0, 255),
@@ -452,7 +416,7 @@ def detect_eye_color(face_roi: np.ndarray, face_landmarks) -> Optional[str]:
     y2 = min(h, max_y + pad)
 
     eye_roi = face_roi[y1:y2, x1:x2]
-    # Resize for more stable KMeans
+
     eye_roi_resize = cv2.resize(eye_roi, (40, 40), interpolation=cv2.INTER_AREA)
 
     if eye_roi_resize.size == 0:
@@ -463,9 +427,6 @@ def detect_eye_color(face_roi: np.ndarray, face_landmarks) -> Optional[str]:
         return classify_eye_color(dom_rgb)
     return None
 
-# --------------------------------------------------------------------
-# HAND TRACKER
-# --------------------------------------------------------------------
 class HandTracker:
     def __init__(self, min_detection_confidence=0.5, min_tracking_confidence=0.5):
         self.hands = mp_hands.Hands(
@@ -491,7 +452,7 @@ class HandTracker:
 
         mpdraw = mp_drawing
         for i, hlms in enumerate(hand_landmarks):
-            # Convert user config colors from (R,G,B) to (B,G,R)
+
             hl_color = config.hand_landmark_color[::-1]
             hc_color = config.hand_connection_color[::-1]
             mpdraw.draw_landmarks(
@@ -505,7 +466,7 @@ class HandTracker:
                 label = handedness[i].classification[0].label
                 score = handedness[i].classification[0].score
                 text = f"{label}: {score:.2f}"
-                # We'll place text near the wrist
+
                 wrist_lm = hlms.landmark[mp_hands.HandLandmark.WRIST]
                 h, w, _ = image.shape
                 cx, cy = int(wrist_lm.x * w), int(wrist_lm.y * h)
@@ -513,9 +474,6 @@ class HandTracker:
                 cv2.putText(image, text, (cx, cy - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, ht_color, 2)
         return image
 
-# --------------------------------------------------------------------
-# FACE PIPELINE
-# --------------------------------------------------------------------
 class FacePipeline:
     def __init__(self, config: PipelineConfig):
         self.config = config
@@ -528,19 +486,18 @@ class FacePipeline:
 
     def initialize(self):
         try:
-            # YOLO for face detection
+
             self.detector = YOLOFaceDetector(
                 model_path=self.config.detector['model_path'],
                 device=self.config.detector['device']
             )
-            # DeepSort tracking
+
             self.tracker = FaceTracker(max_age=self.config.tracker['max_age'])
-            # FaceNet embedder
+
             self.facenet = FaceNetEmbedder(device=self.config.detector['device'])
-            # Database
+
             self.db = FaceDatabase()
 
-            # Hand tracker if enabled
             if self.config.hand['enable']:
                 self.hand_tracker = HandTracker(
                     min_detection_confidence=self.config.hand['min_detection_confidence'],
@@ -564,13 +521,12 @@ class FacePipeline:
             return frame, []
 
         try:
-            # YOLO detection + DeepSort tracking
+
             detections = self.detector.detect(frame, self.config.detection_conf_thres)
             tracked_objs = self.tracker.update(detections, frame)
             annotated = frame.copy()
             results = []
 
-            # Hand detection if enabled
             hand_landmarks_list = None
             handedness_list = None
             if self.config.hand['enable'] and self.hand_tracker:
@@ -594,19 +550,18 @@ class FacePipeline:
                     logger.warning(f"Empty face ROI for track={track_id}")
                     continue
 
-                # Anti-spoofing
                 is_spoofed = False
                 if self.config.anti_spoof.get('enable', True):
                     is_spoofed = not self.is_real_face(face_roi)
                     if is_spoofed:
-                        cls = 1  # Mark as spoofed
+                        cls = 1  
 
                 if is_spoofed:
                     box_color_bgr = self.config.spoofed_bbox_color[::-1]
                     name = "Spoofed"
                     similarity = 0.0
                 else:
-                    # Face embedding + recognition
+
                     emb = self.facenet.get_embedding(face_roi)
                     if emb is not None and self.config.recognition.get('enable', True):
                         name, similarity = self.recognize_face(emb, self.config.recognition_conf_thres)
@@ -623,17 +578,16 @@ class FacePipeline:
                 cv2.putText(annotated, label_text, (x1, y1 - 10),
                             cv2.FONT_HERSHEY_SIMPLEX, 0.5, box_color_bgr, 2)
 
-                # Blink detection
                 blink = False
                 if self.config.blink.get('enable', False):
                     blink, left_ear, right_ear, left_eye_pts, right_eye_pts = detect_blink(
                         face_roi, threshold=self.config.blink.get('ear_thresh', 0.25)
                     )
                     if left_eye_pts is not None and right_eye_pts is not None:
-                        # Shift points to global coords
+
                         le_g = left_eye_pts + np.array([x1, y1])
                         re_g = right_eye_pts + np.array([x1, y1])
-                        # Outline eyes
+
                         eye_outline_bgr = self.config.eye_outline_color[::-1]
                         cv2.polylines(annotated, [le_g], True, eye_outline_bgr, 1)
                         cv2.polylines(annotated, [re_g], True, eye_outline_bgr, 1)
@@ -644,14 +598,13 @@ class FacePipeline:
                                         cv2.FONT_HERSHEY_SIMPLEX, 0.5,
                                         blink_msg_color, 2)
 
-                # Face mesh + eye color
                 face_mesh_landmarks = None
                 eye_color_name = None
                 if (self.config.face_mesh_options.get('enable') or 
                     self.config.eye_color.get('enable')):
                     face_mesh_landmarks = process_face_mesh(face_roi)
                     if face_mesh_landmarks:
-                        # If user wants to draw face mesh
+
                         if self.config.face_mesh_options.get('enable', False):
                             draw_face_mesh(
                                 annotated[y1:y2, x1:x2],
@@ -659,7 +612,7 @@ class FacePipeline:
                                 self.config.face_mesh_options,
                                 self.config
                             )
-                        # Eye color
+
                         if self.config.eye_color.get('enable', False):
                             color_found = detect_eye_color(face_roi, face_mesh_landmarks)
                             if color_found:
@@ -672,7 +625,6 @@ class FacePipeline:
                                     text_col_bgr, 2
                                 )
 
-                # Record result
                 detection_info = {
                     "track_id": track_id,
                     "bbox": (x1, y1, x2, y2),
@@ -724,9 +676,6 @@ class FacePipeline:
     def cosine_similarity(a: np.ndarray, b: np.ndarray) -> float:
         return float(np.dot(a, b) / ((np.linalg.norm(a)*np.linalg.norm(b)) + 1e-6))
 
-# --------------------------------------------------------------------
-# GLOBAL LOADER
-# --------------------------------------------------------------------
 pipeline = None
 def load_pipeline() -> FacePipeline:
     global pipeline
@@ -736,9 +685,6 @@ def load_pipeline() -> FacePipeline:
         pipeline.initialize()
     return pipeline
 
-# --------------------------------------------------------------------
-# UTILITY: HEX <-> BGR
-# --------------------------------------------------------------------
 def hex_to_bgr(hexstr: str) -> Tuple[int,int,int]:
     if not hexstr.startswith('#'):
         hexstr = '#' + hexstr
@@ -754,16 +700,13 @@ def bgr_to_hex(bgr: Tuple[int,int,int]) -> str:
     b,g,r = bgr
     return f"#{r:02x}{g:02x}{b:02x}"
 
-# --------------------------------------------------------------------
-# GRADIO CALLBACKS
-# --------------------------------------------------------------------
 def update_config(
-    # toggles
+
     enable_recognition, enable_antispoof, enable_blink, enable_hand, enable_eyecolor, enable_facemesh,
     show_tesselation, show_contours, show_irises,
-    # thresholds
+
     detection_conf, recognition_thresh, antispoof_thresh, blink_thresh, hand_det_conf, hand_track_conf,
-    # colors
+
     bbox_hex, spoofed_hex, unknown_hex, eye_hex, blink_hex,
     hand_landmark_hex, hand_connect_hex, hand_text_hex,
     mesh_hex, contour_hex, iris_hex, eye_color_text_hex
@@ -771,7 +714,6 @@ def update_config(
     pl = load_pipeline()
     cfg = pl.config
 
-    # Toggles
     cfg.recognition['enable'] = enable_recognition
     cfg.anti_spoof['enable'] = enable_antispoof
     cfg.blink['enable'] = enable_blink
@@ -783,7 +725,6 @@ def update_config(
     cfg.face_mesh_options['contours'] = show_contours
     cfg.face_mesh_options['irises'] = show_irises
 
-    # Thresholds
     cfg.detection_conf_thres = detection_conf
     cfg.recognition_conf_thres = recognition_thresh
     cfg.anti_spoof['lap_thresh'] = antispoof_thresh
@@ -791,7 +732,6 @@ def update_config(
     cfg.hand['min_detection_confidence'] = hand_det_conf
     cfg.hand['min_tracking_confidence'] = hand_track_conf
 
-    # Colors
     cfg.bbox_color = hex_to_bgr(bbox_hex)[::-1]
     cfg.spoofed_bbox_color = hex_to_bgr(spoofed_hex)[::-1]
     cfg.unknown_bbox_color = hex_to_bgr(unknown_hex)[::-1]
@@ -823,7 +763,7 @@ def enroll_user(label_name: str, filepaths: List[str]) -> str:
         img_bgr = cv2.imread(path)
         if img_bgr is None:
             continue
-        # Detect face(s)
+
         dets = pl.detector.detect(img_bgr, pl.config.detection_conf_thres)
         for x1, y1, x2, y2, conf, cls in dets:
             roi = img_bgr[y1:y2, x1:x2]
@@ -898,14 +838,10 @@ def process_test_image(img: np.ndarray) -> Tuple[np.ndarray, str]:
     result_rgb = cv2.cvtColor(processed, cv2.COLOR_BGR2RGB)
     return result_rgb, str(detections)
 
-# --------------------------------------------------------------------
-# BUILD GRADIO APP
-# --------------------------------------------------------------------
 def build_app():
     with gr.Blocks() as demo:
         gr.Markdown("# Complete Face Recognition System (Single-Image) with Mediapipe")
 
-        # Tab: Image Test
         with gr.Tab("Image Test"):
             gr.Markdown("Upload a single image to detect faces, run blink detection, face mesh, hand tracking, etc.")
             test_in = gr.Image(type="numpy", label="Upload Image")
@@ -919,7 +855,6 @@ def build_app():
                 outputs=[test_out, test_info],
             )
 
-        # Tab: Configuration
         with gr.Tab("Configuration"):
             gr.Markdown("Adjust toggles, thresholds, and colors. Click Save to persist changes.")
 
@@ -931,7 +866,6 @@ def build_app():
                 enable_eyecolor = gr.Checkbox(label="Enable Eye Color Detection", value=False)
                 enable_facemesh = gr.Checkbox(label="Enable Face Mesh", value=False)
 
-            # Face Mesh sub-options
             gr.Markdown("**Face Mesh Options**")
             with gr.Row():
                 show_tesselation = gr.Checkbox(label="Tesselation", value=False)
@@ -978,7 +912,6 @@ def build_app():
                 outputs=[save_msg]
             )
 
-        # Tab: Database Management
         with gr.Tab("Database Management"):
             gr.Markdown("Enroll multiple images per user, search by name or image, remove users, list all users.")
 
@@ -1046,10 +979,7 @@ def build_app():
 
     return demo
 
-# --------------------------------------------------------------------
-# MAIN
-# --------------------------------------------------------------------
 if __name__ == "__main__":
     app = build_app()
-    # queue() is optional if concurrency is expected
-    app.queue().launch(server_name="0.0.0.0", server_port=7860)
+
+    app.queue().launch(server_name="0.0.0.0", server_port=7860)