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

matrice_analytics/post_processing/usecases/footfall.py

@@ -1,7 +1,10 @@
 from typing import Any, Dict, List, Optional
 from dataclasses import asdict
 import time
+import math
+import numpy as np
 from datetime import datetime, timezone
+from collections import defaultdict, deque
 
 from ..core.base import BaseProcessor, ProcessingContext, ProcessingResult, ConfigProtocol, ResultFormat
 from ..utils import (
@@ -19,6 +22,95 @@ from ..utils import (
 from dataclasses import dataclass, field
 from ..core.config import BaseConfig, AlertConfig, ZoneConfig
 
+class TrajectoryCorrector:
+    """
+    Handles Velocity-Fusion logic to correct model orientation errors.
+    Stores history of track centers and applies EMA smoothing.
+    """
+    def __init__(self):
+        # track_id -> { "centers": deque, "smooth_angle": float }
+        self.history = defaultdict(lambda: {
+            "centers": deque(maxlen=10), 
+            "angles": deque(maxlen=5), 
+            "smooth_angle": None        
+        })
+
+    def get_direction_label(self, angle):
+        """
+        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)
+
+        # --- FIX 1: ROTATE MODEL ANGLE ---
+        if raw_angle_deg is None: raw_angle_deg = 0.0
+        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"])
+        
+        # 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  
+        
+        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
+
+        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
+            
+        # Look back 5 frames for stability
+        lookback = min(len(centers), 5)
+        (x_past, y_past) = centers[-lookback]
+        (x_now, y_now) = centers[-1]
+        
+        dx = x_now - x_past
+        dy = y_now - y_past
+        
+        # THRESHOLD: 2.5 pixels
+        if math.hypot(dx, dy) < 0.5:
+            return None
+            
+        return math.degrees(math.atan2(-dy, dx)) % 360
+
 @dataclass
 class FootFallConfig(BaseConfig):
     """Configuration for footfall use case."""
@@ -46,6 +138,7 @@ class FootFallConfig(BaseConfig):
 
     target_categories: List[str] = field(
         default_factory=lambda: ['person']
+
     )
     
     def validate(self) -> List[str]:
@@ -79,9 +172,12 @@ class FootFallUseCase(BaseProcessor):
         self.category = "retail"
         self.CASE_TYPE: Optional[str] = 'footfall'
         self.CASE_VERSION: Optional[str] = '1.1'
-        self.target_categories = ['person'] #['person', 'people','human','man','woman','male','female']
+        self.target_categories = ['person']
         self.smoothing_tracker = None
         self.tracker = None
+        
+        # Initialize the Velocity Logic 
+        self.trajectory_corrector = TrajectoryCorrector()
         self._total_frame_counter = 0
         self._global_frame_offset = 0
         self._tracking_start_time = None
@@ -105,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
@@ -144,9 +224,61 @@ class FootFallUseCase(BaseProcessor):
                     match_thresh=0.8)
                 self.tracker = AdvancedTracker(tracker_config)
                 self.logger.info("Initialized AdvancedTracker for People Counting")
+            
+            # 1. Run Standard Tracker (Assigns IDs)
             processed_data = self.tracker.update(processed_data)
+            
+            # =========================================================
+            # NEW: INJECT VELOCITY FUSION LOGIC (CORRECTED)
+            # =========================================================
+            for det in processed_data:
+                track_id = det.get("track_id")
+
+                # 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("angle", det.get("raw_angle", det.get("orientation", 0.0)))
+                
+                if track_id is not None and bbox:
+                    # Calculate Center (cx, cy)
+                    cx = int((bbox[0] + bbox[2]) / 2)
+                    cy = int((bbox[1] + bbox[3]) / 2)
+                    
+                    # Run Correction (Velocity + EMA + 90 Fix)
+                    # 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
+                    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 failed: {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
@@ -461,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)
@@ -646,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()),
@@ -655,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

@@ -535,6 +535,10 @@ class LicensePlateMonitorUseCase(BaseProcessor):
         self.plate_logger: Optional[LicensePlateMonitorLogger] = None
         self._logging_enabled = True # False  //ToDo: DISABLED FOR NOW, ENABLED FOR PRODUCTION. ##
         self._plate_logger_initialized = False  # Track if plate logger has been initialized
+        
+        # Track which track_ids have been logged to avoid duplicate logging
+        # Only log confirmed/consensus plates, not every OCR prediction
+        self._logged_track_ids: set = set()
 
         # Initialize instant alert manager (will be lazily initialized on first process() call)
         self.alert_manager: Optional[ALERT_INSTANCE] = None
@@ -942,6 +946,8 @@ class LicensePlateMonitorUseCase(BaseProcessor):
         self._unique_plate_texts = {}
         self.helper = {}
         self.unique_plate_track = {}
+        # Reset logged track_ids to allow fresh logging
+        self._logged_track_ids = set()
         self.logger.info("Plate tracking state reset")
 
     def reset_all_tracking(self) -> None:
@@ -1106,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:
@@ -1147,13 +1153,19 @@ class LicensePlateMonitorUseCase(BaseProcessor):
     
     async def _log_detected_plates(self, detections: List[Dict[str, Any]], config: LicensePlateMonitorConfig, 
                             stream_info: Optional[Dict[str, Any]], image_bytes: Optional[bytes] = None) -> None:
-        """Log all detected plates to RPC server with cooldown."""
+        """
+        Log confirmed/consensus plates to RPC server.
+        
+        Only logs plates that have reached consensus (are in _tracked_plate_texts),
+        and only logs each track_id once to avoid duplicate logging of garbage OCR predictions.
+        Uses the confirmed consensus plate text, not the raw frame-by-frame OCR output.
+        """
         # Enhanced logging for diagnostics
         print(f"[LP_LOGGING] Starting plate logging check - detections count: {len(detections)}")
         self.logger.info(f"[LP_LOGGING] Starting plate logging check - detections count: {len(detections)}")
-        self.logger.info(f"[LP_LOGGING] Logging enabled: {self._logging_enabled}, Plate logger exists: {self.plate_logger is not None}, Stream info exists: {stream_info is not None}")
+        self.logger.info(f"[LP_LOGGING] Logging enabled: {self._logging_enabled}, Plate logger exists: {self.plate_logger is not None}")
+        self.logger.info(f"[LP_LOGGING] Confirmed plates (tracked): {len(self._tracked_plate_texts)}, Already logged tracks: {len(self._logged_track_ids)}")
         
-        #self._logging_enabled = False # ToDo: DISABLED FOR NOW, ENABLED FOR PRODUCTION
         if not self._logging_enabled:
             print("[LP_LOGGING] Plate logging is DISABLED")
             self.logger.warning("[LP_LOGGING] Plate logging is DISABLED - logging_enabled flag is False")
@@ -1164,11 +1176,6 @@ class LicensePlateMonitorUseCase(BaseProcessor):
             self.logger.warning("[LP_LOGGING] Plate logging SKIPPED - plate_logger is not initialized (lpr_server_id may not be configured)")
             return
         
-        # if not stream_info:
-        #     print("[LP_LOGGING] Plate logging SKIPPED - stream_info is None")
-        #     self.logger.warning("[LP_LOGGING] Plate logging SKIPPED - stream_info is None")
-        #     return
-        
         print("[LP_LOGGING] All pre-conditions met, proceeding with plate logging")
         self.logger.info(f"[LP_LOGGING] All pre-conditions met, proceeding with plate logging")
         
@@ -1195,35 +1202,45 @@ class LicensePlateMonitorUseCase(BaseProcessor):
                 else:
                     self.logger.warning(f"[LP_LOGGING] Failed to decode image bytes")
             except Exception as e:
-                #pass
                 self.logger.error(f"[LP_LOGGING] Exception while encoding frame image: {e}", exc_info=True)
         else:
             self.logger.info(f"[LP_LOGGING] No image_bytes provided, sending without image")
         
-        # Collect all unique plates from current detections
-        plates_to_log = set()
-        detections_without_text = 0
+        # Only log CONFIRMED/CONSENSUS plates from _tracked_plate_texts
+        # Avoid logging every raw OCR prediction - only log final confirmed plate per track_id
+        plates_to_log = {}  # track_id -> consensus_plate_text
+        
         for det in detections:
-            plate_text = det.get('plate_text')
-            if not plate_text:
-                detections_without_text += 1
+            track_id = det.get('track_id')
+            if track_id is None:
                 continue
-            plates_to_log.add(plate_text)
+            
+            # Skip if this track_id has already been logged
+            if track_id in self._logged_track_ids:
+                self.logger.debug(f"[LP_LOGGING] Skipping track_id={track_id} - already logged")
+                continue
+            
+            # Only log if this track_id has a confirmed/consensus plate
+            if track_id in self._tracked_plate_texts:
+                consensus_plate = self._tracked_plate_texts[track_id]
+                if consensus_plate:
+                    plates_to_log[track_id] = consensus_plate
+                    self.logger.debug(f"[LP_LOGGING] Found confirmed plate for track_id={track_id}: {consensus_plate}")
         
-        print(f"[LP_LOGGING] Collected {len(plates_to_log)} unique plates to log: {plates_to_log}")
-        self.logger.info(f"[LP_LOGGING] Collected {len(plates_to_log)} unique plates to log: {plates_to_log}")
-        if detections_without_text > 0:
-            self.logger.warning(f"[LP_LOGGING] {detections_without_text} detections have NO plate_text (OCR may have failed or not run yet)")
+        confirmed_count = len(plates_to_log)
+        raw_ocr_count = sum(1 for d in detections if d.get('plate_text'))
+        print(f"[LP_LOGGING] Confirmed plates to log: {confirmed_count} (from {raw_ocr_count} raw OCR detections)")
+        self.logger.info(f"[LP_LOGGING] Confirmed plates to log: {confirmed_count}, Raw OCR detections: {raw_ocr_count}")
+        self.logger.info(f"[LP_LOGGING] Plates: {list(plates_to_log.values())}")
         
-        # Log each unique plate directly with await (respecting cooldown)
+        # Log each confirmed plate (respecting cooldown)
         if plates_to_log:
-            print(f"[LP_LOGGING] Logging {len(plates_to_log)} plates with cooldown={config.plate_log_cooldown}s")
-            self.logger.info(f"[LP_LOGGING] Logging {len(plates_to_log)} plates with cooldown={config.plate_log_cooldown}s")
+            print(f"[LP_LOGGING] Logging {len(plates_to_log)} confirmed plates with cooldown={config.plate_log_cooldown}s")
+            self.logger.info(f"[LP_LOGGING] Logging {len(plates_to_log)} confirmed plates with cooldown={config.plate_log_cooldown}s")
             try:
-                # Call log_plate directly with await for each plate
-                for plate_text in plates_to_log:
-                    print(f"[LP_LOGGING] Processing plate: {plate_text}")
-                    self.logger.info(f"[LP_LOGGING] Processing plate: {plate_text}")
+                for track_id, plate_text in plates_to_log.items():
+                    print(f"[LP_LOGGING] Processing confirmed plate: {plate_text} (track_id={track_id})")
+                    self.logger.info(f"[LP_LOGGING] Processing confirmed plate: {plate_text} (track_id={track_id})")
                     try:
                         result = await self.plate_logger.log_plate(
                             plate_text=plate_text,
@@ -1232,25 +1249,26 @@ class LicensePlateMonitorUseCase(BaseProcessor):
                             image_data=image_data,
                             cooldown=config.plate_log_cooldown
                         )
-                        status = "SENT" if result else "SKIPPED (cooldown)"
-                        print(f"[LP_LOGGING] Plate {plate_text}: {status}")
-                        self.logger.info(f"[LP_LOGGING] Plate {plate_text}: {status}")
+                        if result:
+                            # Mark this track_id as logged to avoid duplicate logging
+                            self._logged_track_ids.add(track_id)
+                            print(f"[LP_LOGGING] Plate {plate_text}: SENT (track_id={track_id} marked as logged)")
+                            self.logger.info(f"[LP_LOGGING] Plate {plate_text}: SENT (track_id={track_id} marked as logged)")
+                        else:
+                            print(f"[LP_LOGGING] Plate {plate_text}: SKIPPED (cooldown)")
+                            self.logger.info(f"[LP_LOGGING] Plate {plate_text}: SKIPPED (cooldown)")
                     except Exception as e:
-                        #pass
                         print(f"[LP_LOGGING] ERROR - Plate {plate_text} failed: {e}")
                         self.logger.error(f"[LP_LOGGING] Plate {plate_text} raised exception: {e}", exc_info=True)
                 
                 print("[LP_LOGGING] Plate logging complete")
-                self.logger.info(f"[LP_LOGGING] Plate logging complete")
+                self.logger.info(f"[LP_LOGGING] Plate logging complete - {len(self._logged_track_ids)} total tracks logged so far")
             except Exception as e:
-                print(f"[LP_LOGGING] CRITICAL ERROR during plate logging: {e}")
-                
                 print(f"[LP_LOGGING] CRITICAL ERROR during plate logging: {e}")
                 self.logger.error(f"[LP_LOGGING] CRITICAL ERROR during plate logging: {e}", exc_info=True)
-                pass
         else:
-            print("[LP_LOGGING] No plates to log")
-            self.logger.info(f"[LP_LOGGING] No plates to log (plates_to_log is empty)")
+            print("[LP_LOGGING] No confirmed plates to log (plates may still be reaching consensus)")
+            self.logger.info(f"[LP_LOGGING] No confirmed plates to log (waiting for consensus)")
 
     async def process(self, data: Any, config: ConfigProtocol, input_bytes: Optional[bytes] = None, 
                 context: Optional[ProcessingContext] = None, stream_info: Optional[Dict[str, Any]] = None) -> ProcessingResult:
@@ -1298,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}")