matrice-analytics 0.1.106__py3-none-any.whl → 0.1.124__py3-none-any.whl

matrice_analytics/post_processing/usecases/footfall.py

@@ -30,36 +30,70 @@ class TrajectoryCorrector:
     def __init__(self):
         # track_id -> { "centers": deque, "smooth_angle": float }
         self.history = defaultdict(lambda: {
-            "centers": deque(maxlen=10),  # Lookback for velocity
-            "smooth_angle": None          # For EMA smoothing
+            "centers": deque(maxlen=10), 
+            "angles": deque(maxlen=5), 
+            "smooth_angle": None        
         })
 
-    def update_and_correct(self, track_id, center, raw_angle_deg):
+    def get_direction_label(self, angle):
         """
-        Returns the corrected angle based on velocity fusion.
+        Your custom logic for Front/Back/Left/Right
+        """
+        if angle is None: return "unknown"
+        angle = angle % 360
+        if 45 <= angle < 135: return "back"
+        elif 135 <= angle < 225: return "left"
+        elif 225 <= angle < 315: return "front"
+        else: return "right"
+
+    def update_and_get_label(self, track_id, center, raw_angle_deg):
+        """
+        1. Fixes Angle (+90)
+        2. Calculates Velocity
+        3. Applies EMA Smoothing
+        4. Returns (Smooth_Angle, Label_String)
         """
         state = self.history[track_id]
         state["centers"].append(center)
-        
-        # 1. Calculate Velocity Angle
-        velocity_angle = self._compute_velocity_angle(state["centers"])
-        
-        # 2. Apply +90 Fix to Raw Model Angle (Matches your successful tests)
-        # Note: raw_angle_deg comes from predict.py
+
+        # --- FIX 1: ROTATE MODEL ANGLE ---
         if raw_angle_deg is None: raw_angle_deg = 0.0
-        model_angle = (raw_angle_deg + 90) % 360
-        
-        # 3. Determine Target (Velocity vs Model)
-        # Hybrid Logic: If moving (velocity valid), use Physics. Else, use Visuals.
-        target_angle = velocity_angle if velocity_angle is not None else model_angle
+        fixed_raw_angle = (raw_angle_deg + 90) % 360
+        state["angles"].append(fixed_raw_angle)
+
+        # --- FIX 2: CALCULATE VELOCITY ---
+        motion_angle = self._compute_motion_angle(state["centers"])
         
-        # 4. Apply EMA Smoothing (The Jitter Killer)
-        # alpha=0.2 means we trust new data 20%, old history 80%
-        state["smooth_angle"] = self._apply_ema(state["smooth_angle"], target_angle, alpha=0.2)
+        # Decide Target Angle
+        if motion_angle is not None:
+            target_angle = motion_angle
+        elif fixed_raw_angle is not None:
+            target_angle = fixed_raw_angle
+        elif state["smooth_angle"] is not None:
+            target_angle = state["smooth_angle"]
+        else:
+            target_angle = 0.0
+
+        # --- FIX 3: EMA SMOOTHING ---
+        alpha = 0.2  
         
-        return state["smooth_angle"]
+        if state["smooth_angle"] is None:
+            state["smooth_angle"] = target_angle
+        else:
+            prev_rad = math.radians(state["smooth_angle"])
+            curr_rad = math.radians(target_angle)
+            
+            new_sin = (1 - alpha) * math.sin(prev_rad) + alpha * math.sin(curr_rad)
+            new_cos = (1 - alpha) * math.cos(prev_rad) + alpha * math.cos(curr_rad)
+            
+            state["smooth_angle"] = math.degrees(math.atan2(new_sin, new_cos)) % 360
 
-    def _compute_velocity_angle(self, centers):
+        final_angle = state["smooth_angle"]
+        label = self.get_direction_label(final_angle)
+
+        return final_angle, label
+
+    def _compute_motion_angle(self, centers):
         if len(centers) < 2: 
             return None
             
@@ -71,27 +105,12 @@ class TrajectoryCorrector:
         dx = x_now - x_past
         dy = y_now - y_past
         
-        # THRESHOLD: 2.5 pixels (Validated in your tests)
-        # If moving less than this, velocity is noise.
-        if math.hypot(dx, dy) < 2.5:
+        # THRESHOLD: 2.5 pixels
+        if math.hypot(dx, dy) < 0.5:
             return None
             
-        # Angle calculation (0-360)
         return math.degrees(math.atan2(-dy, dx)) % 360
 
-    def _apply_ema(self, current_smooth, new_target, alpha=0.2):
-        if current_smooth is None:
-            return new_target
-            
-        # Vector smoothing to handle 0/360 wrap-around correctly
-        prev_rad = math.radians(current_smooth)
-        curr_rad = math.radians(new_target)
-        
-        new_sin = (1 - alpha) * math.sin(prev_rad) + alpha * math.sin(curr_rad)
-        new_cos = (1 - alpha) * math.cos(prev_rad) + alpha * math.cos(curr_rad)
-        
-        return math.degrees(math.atan2(new_sin, new_cos)) % 360
-
 @dataclass
 class FootFallConfig(BaseConfig):
     """Configuration for footfall use case."""
@@ -119,6 +138,7 @@ class FootFallConfig(BaseConfig):
 
     target_categories: List[str] = field(
         default_factory=lambda: ['person']
+
     )
     
     def validate(self) -> List[str]:
@@ -181,33 +201,17 @@ class FootFallUseCase(BaseProcessor):
         context.input_format = input_format
         context.confidence_threshold = config.confidence_threshold
 
+        # ... [Keep your standard filtering logic here: confidence, mapping, categories] ...
         if config.confidence_threshold is not None:
             processed_data = filter_by_confidence(data, config.confidence_threshold)
-            self.logger.debug(f"Applied confidence filtering with threshold {config.confidence_threshold}")
         else:
             processed_data = data
-            self.logger.debug("Did not apply confidence filtering since no threshold provided")
 
         if config.index_to_category:
             processed_data = apply_category_mapping(processed_data, config.index_to_category)
-            self.logger.debug("Applied category mapping")
 
         if config.target_categories:
             processed_data = [d for d in processed_data if d.get('category') in self.target_categories]
-            self.logger.debug("Applied category filtering")
-
-        # if config.enable_smoothing:
-        #     if self.smoothing_tracker is None:
-        #         smoothing_config = BBoxSmoothingConfig(
-        #             smoothing_algorithm=config.smoothing_algorithm,
-        #             window_size=config.smoothing_window_size,
-        #             cooldown_frames=config.smoothing_cooldown_frames,
-        #             confidence_threshold=config.confidence_threshold,
-        #             confidence_range_factor=config.smoothing_confidence_range_factor,
-        #             enable_smoothing=True
-        #         )
-        #         self.smoothing_tracker = BBoxSmoothingTracker(smoothing_config)
-        #     processed_data = bbox_smoothing(processed_data, self.smoothing_tracker.config, self.smoothing_tracker)
 
         try:
             from ..advanced_tracker import AdvancedTracker
@@ -225,14 +229,29 @@ class FootFallUseCase(BaseProcessor):
             processed_data = self.tracker.update(processed_data)
             
             # =========================================================
-            # NEW: INJECT VELOCITY FUSION LOGIC
+            # NEW: INJECT VELOCITY FUSION LOGIC (CORRECTED)
             # =========================================================
             for det in processed_data:
                 track_id = det.get("track_id")
-                bbox = det.get("bounding_box", det.get("bbox"))
+
+                # STREAM-SAFE bbox normalization
+                bbox = det.get("bbox") or det.get("bounding_box")
+
+                if isinstance(bbox, dict):
+                    bbox = [
+                        bbox.get("xmin"),
+                        bbox.get("ymin"),
+                        bbox.get("xmax"),
+                        bbox.get("ymax"),
+                    ]
+
+                # Hard safety guard
+                if not bbox or len(bbox) < 4:
+                    continue
+
                 
                 # Check for 'raw_angle' (from predict.py) or 'orientation'
-                raw_angle = det.get("raw_angle", det.get("orientation", 0.0))
+                raw_angle = det.get("angle", det.get("raw_angle", det.get("orientation", 0.0)))
                 
                 if track_id is not None and bbox:
                     # Calculate Center (cx, cy)
@@ -240,21 +259,27 @@ class FootFallUseCase(BaseProcessor):
                     cy = int((bbox[1] + bbox[3]) / 2)
                     
                     # Run Correction (Velocity + EMA + 90 Fix)
-                    final_angle = self.trajectory_corrector.update_and_correct(
+                    # FIX: Unpack both values (Angle AND Label)
+                    final_angle, direction_label = self.trajectory_corrector.update_and_get_label(
                         track_id, 
                         (cx, cy), 
                         raw_angle
                     )
                     
                     # OVERWRITE the detection angle
-                    # This ensures _generate_tracking_stats uses YOUR logic
                     det["orientation"] = final_angle  # For UI
                     det["angle"] = final_angle        # For Analytics
+                    
+                    # FIX: SAVE THE DIRECTION LABEL
+                    det["direction"] = direction_label # "front", "back", etc.
             # =========================================================
 
         except Exception as e:
             self.logger.warning(f"AdvancedTracker/Velocity failed: {e}")
 
+        # ... [The rest of your process method remains exactly the same] ...
+    
+
         self._update_tracking_state(processed_data)
         self._total_frame_counter += 1
 
@@ -568,8 +593,21 @@ class FootFallUseCase(BaseProcessor):
             raw_track_id = det.get("track_id")
             if cat not in self.target_categories or raw_track_id is None:
                 continue
-            bbox = det.get("bounding_box", det.get("bbox"))
+            bbox = det.get("bbox") or det.get("bounding_box")
+
+            if isinstance(bbox, dict):
+                bbox = [
+                    bbox.get("xmin"),
+                    bbox.get("ymin"),
+                    bbox.get("xmax"),
+                    bbox.get("ymax"),
+                ]
+
+            if not bbox or len(bbox) < 4:
+                continue
+
             canonical_id = self._merge_or_register_track(raw_track_id, bbox)
+
             det["track_id"] = canonical_id
             self._per_category_total_track_ids.setdefault(cat, set()).add(canonical_id)
             self._current_frame_track_ids[cat].add(canonical_id)
@@ -753,7 +791,7 @@ class FootFallUseCase(BaseProcessor):
     def _count_categories(self, detections: list, config: FootFallConfig) -> dict:
         counts = {}
         for det in detections:
-            cat = det.get('category', 'unknown')
+            cat = det.get("direction") or "unknown"
             counts[cat] = counts.get(cat, 0) + 1
         return {
             "total_count": sum(counts.values()),
@@ -762,9 +800,12 @@ class FootFallUseCase(BaseProcessor):
                 {
                     "bounding_box": det.get("bounding_box"),
                     "category": det.get("category"),
+                    "direction": det.get("direction"),
                     "confidence": det.get("confidence"),
                     "track_id": det.get("track_id"),
-                    "frame_id": det.get("frame_id")
+                    "frame_id": det.get("frame_id"),
+                    "angle": det.get("angle"),          
+                    "orientation": det.get("orientation") #for UI arrows
                 }
                 for det in detections
             ]

matrice_analytics/post_processing/usecases/license_plate_monitoring.py

@@ -1112,7 +1112,7 @@ class LicensePlateMonitorUseCase(BaseProcessor):
             # Send to alert manager for evaluation
             try:
                 self.logger.info(f"[ALERT_DEBUG] Sending detection event #{i+1} to alert manager...")
-                self.alert_manager.process_detection_event(detection_event)
+                self.alert_manager.process_detection_event(detection_event, stream_info)
                 self.logger.info(f"[ALERT_DEBUG] ✓ Sent detection event to alert manager: plate={plate_text}, confidence={confidence:.2f}")
                 sent_count += 1
             except Exception as e:
@@ -1316,6 +1316,7 @@ class LicensePlateMonitorUseCase(BaseProcessor):
             
             input_format = match_results_structure(data)
             context.input_format = input_format
+            config.confidence_threshold = 0.1
             context.confidence_threshold = config.confidence_threshold
             self._ocr_mode = config.ocr_mode
             self.logger.info(f"Processing license plate monitoring with format: {input_format.value}")