Trying to implement analysis only seperately

src/detection/strategies/geometric.py

@@ -193,3 +193,110 @@ class GeometricProcessor(BaseProcessor):
 
         return frame
 
+    def analyse_frame(self, frame):
+        # self.frame_counter += 1
+        
+        # --- FIX: More efficient frame skipping ---
+        # # Adaptive skipping: process more frequently if drowsiness is detected.
+        # last_level = self.last_indicators.get("drowsiness_level", "Awake")
+        # skip_n = 1 if last_level != "Awake" else self.default_skip
+
+        # if self.frame_counter % skip_n != 0:
+        #     # If we have a cached frame, return it to avoid re-drawing.
+        #     if self.last_drawn_frame is not None:
+        #         return self.last_drawn_frame, self.last_indicators
+        #     # Fallback if the first frame was skipped (unlikely but safe)
+        #     else:
+        #         return frame.copy(), self.last_indicators
+
+        # --- CORE FRAME PROCESSING ---
+        original_frame = frame.copy()
+        h_orig, w_orig, _ = original_frame.shape
+        
+        # Optimization: Downscale frame for faster processing
+        small_frame = cv2.resize(original_frame, (0, 0), fx=self.downscale_factor, fy=self.downscale_factor, interpolation=cv2.INTER_AREA)
+        h, w, _ = small_frame.shape
+
+        # All processing is done on the `small_frame` for speed.
+        gray = cv2.cvtColor(small_frame, cv2.COLOR_BGR2GRAY)
+        brightness = np.mean(gray)
+        
+        drowsiness_indicators = {"drowsiness_level": "Awake", "lighting": "Good", "details": {}}
+        face_landmarks_data = None
+
+        if brightness < self.settings['low_light_thresh']:
+            drowsiness_indicators["lighting"] = "Low"
+        else:
+            # Convert the SMALL frame to RGB for MediaPipe
+            img_rgb = cv2.cvtColor(small_frame, cv2.COLOR_BGR2RGB)
+            img_rgb.flags.writeable = False # Performance enhancement
+            results = self.face_mesh.process(img_rgb)
+            img_rgb.flags.writeable = True
+
+            if results.multi_face_landmarks:
+                face_landmarks_data = results.multi_face_landmarks[0]
+                landmarks = face_landmarks_data.landmark
+                score = 0
+                weights = self.settings['indicator_weights']
+
+                # --- Drowsiness Calculations (on small frame dimensions 'h', 'w') ---
+                ear_left = calculate_ear([landmarks[i] for i in self.L_EYE],(h,w))
+                ear_right = calculate_ear([landmarks[i] for i in self.R_EYE],(h,w))
+                ear = (ear_left + ear_right) / 2.0
+                
+                if ear < self.settings['eye_ar_thresh']: self.counters['eye_closure']+=1
+                else: self.counters['eye_closure']=0
+                if self.counters['eye_closure'] >= self.settings['eye_ar_consec_frames']: score += weights['eye_closure']
+
+                mar = calculate_mar([landmarks[i] for i in self.MOUTH], (h, w))
+                if mar > self.settings['yawn_mar_thresh']: self.counters['yawning']+=1
+                else: self.counters['yawning']=0
+                if self.counters['yawning'] >= self.settings['yawn_consec_frames']: score += weights['yawning']
+
+                # --- Head Pose Estimation (on small frame dimensions 'h', 'w') ---
+                face_3d_model = np.array([
+                    [0.0, 0.0, 0.0],            # Nose tip
+                    [0.0, -330.0, -65.0],        # Chin
+                    [-225.0, 170.0, -135.0],     # Left eye left corner
+                    [225.0, 170.0, -135.0],      # Right eye right corner
+                    [-150.0, -150.0, -125.0],    # Left Mouth corner
+                    [150.0, -150.0, -125.0]      # Right mouth corner
+                ], dtype=np.float32)
+                
+                face_2d_points = np.array([(landmarks[i].x * w, landmarks[i].y * h) for i in self.HEAD_POSE_LANDMARKS], dtype=np.float32)
+                cam_matrix = np.array([[w, 0, w/2], [0, w, h/2], [0, 0, 1]], dtype=np.float32)
+                
+                _, rvec, _ = cv2.solvePnP(face_3d_model, face_2d_points, cam_matrix, self.zeros_4x1, flags=cv2.SOLVEPNP_EPNP)
+                rmat, _ = cv2.Rodrigues(rvec)
+                angles, _, _, _, _, _ = cv2.RQDecomp3x3(rmat)
+                pitch, yaw = angles[0], angles[1]
+
+                if pitch > self.settings['head_nod_thresh']: self.counters['head_nod']+=1
+                else: self.counters['head_nod']=0
+                if self.counters['head_nod'] >= self.settings['head_pose_consec_frames']: score += weights['head_nod']
+
+                if abs(yaw) > self.settings['head_look_away_thresh']: self.counters['looking_away']+=1
+                else: self.counters['looking_away']=0
+                if self.counters['looking_away'] >= self.settings['head_pose_consec_frames']: score += weights['looking_away']
+
+                # Determine final drowsiness level based on score
+                levels = self.settings['drowsiness_levels']
+                if score >= levels['very_drowsy_threshold']:
+                    drowsiness_indicators['drowsiness_level'] = "Very Drowsy"
+                elif score >= levels['slightly_drowsy_threshold']:
+                    drowsiness_indicators['drowsiness_level'] = "Slightly Drowsy"
+
+                drowsiness_indicators['details']['Score'] = score
+
+        # --- Update state for next frame (skipped or processed) ---
+        self.last_indicators = drowsiness_indicators
+        self.last_landmarks = face_landmarks_data
+
+        # --- Draw visuals on the ORIGINAL frame for high-quality output ---
+        # processed_frame = self.draw_visuals(original_frame, drowsiness_indicators, face_landmarks_data)
+        
+        # --- FIX: Cache the newly drawn frame ---
+        # self.last_drawn_frame = processed_frame
+
+        # --- FIX: Return only the two values expected by the Gradio app ---
+        return drowsiness_indicators