matrice-analytics 0.1.70__py3-none-any.whl → 0.1.96__py3-none-any.whl

matrice_analytics/post_processing/usecases/color_detection.py

@@ -1114,18 +1114,18 @@ class ColorDetectionUseCase(BaseProcessor):
         stats = self.zone_vehicle_stats
 
         # TOTAL SINCE section
-        human_text_lines.append(f"TOTAL SINCE {start_timestamp}:")
-        for zone_name, vehicles in stats.items():
-            total_in_zone = sum(sum(colors.values()) for colors in vehicles.values())
-            if config.zone_config:
-                human_text_lines.append(f"\t{zone_name}:")
-            human_text_lines.append(f"\t\t- Total Detected: {total_in_zone}")
-
-            for vehicle_type, colors in vehicles.items():
-                total_type_count = sum(colors.values())
-                human_text_lines.append(f"\t\t- {vehicle_type}: {total_type_count}")
-                for color, count in colors.items():
-                    human_text_lines.append(f"\t\t\t- {color}: {count}")
+        # human_text_lines.append(f"TOTAL SINCE {start_timestamp}:")
+        # for zone_name, vehicles in stats.items():
+        #     total_in_zone = sum(sum(colors.values()) for colors in vehicles.values())
+        #     if config.zone_config:
+        #         human_text_lines.append(f"\t{zone_name}:")
+        #     human_text_lines.append(f"\t\t- Total Detected: {total_in_zone}")
+
+        #     for vehicle_type, colors in vehicles.items():
+        #         total_type_count = sum(colors.values())
+        #         human_text_lines.append(f"\t\t- {vehicle_type}: {total_type_count}")
+        #         for color, count in colors.items():
+        #             human_text_lines.append(f"\t\t\t- {color}: {count}")
 
         current_counts_categories = []
         for cat, count in per_category_count.items():
@@ -1179,13 +1179,13 @@ class ColorDetectionUseCase(BaseProcessor):
                             }
             })
 
-        if alerts:
-            for alert in alerts:
-                human_text_lines.append(f"Alerts: {alert.get('settings', {})} sent @ {current_timestamp}")
-        else:
-            human_text_lines.append("Alerts: None")
+        # if alerts:
+        #     for alert in alerts:
+        #         human_text_lines.append(f"Alerts: {alert.get('settings', {})} sent @ {current_timestamp}")
+        # else:
+        #     human_text_lines.append("Alerts: None")
 
-        human_text = "\n".join(human_text_lines)
+        # human_text = "\n".join(human_text_lines)
         reset_settings = [
                 {
                     "interval_type": "daily",
@@ -1202,6 +1202,7 @@ class ColorDetectionUseCase(BaseProcessor):
                             detections=detections, human_text=human_text, camera_info=camera_info, alerts=alerts, alert_settings=alert_settings,
                             reset_settings=reset_settings, start_time=high_precision_start_timestamp ,
                             reset_time=high_precision_reset_timestamp)
+        tracking_stat['target_categories'] = self.target_categories
 
         tracking_stats.append(tracking_stat)
         return tracking_stats

matrice_analytics/post_processing/usecases/customer_service.py

@@ -3,6 +3,9 @@ Customer service use case implementation.
 
 This module provides comprehensive customer service analytics including staff utilization,
 service interactions, area occupancy analysis, and business intelligence metrics.
+
+Now includes integrated tracking support for plain YOLOv8 frame-wise predictions
+(no external ByteTrack dependency).
 """
 
 from typing import Any, Dict, List, Optional, Tuple
@@ -21,6 +24,11 @@ from ..utils import (
     calculate_distance,
     match_results_structure
 )
+# Import business metrics manager for publishing aggregated metrics
+from ..utils.business_metrics_manager_utils import (
+    BUSINESS_METRICS_MANAGER, 
+    BusinessMetricsManagerFactory
+)
 
 
 def assign_person_by_area(detections, customer_areas, staff_areas):
@@ -68,7 +76,327 @@ class CustomerServiceUseCase(BaseProcessor):
         # --- Persistent sets for global unique counting across chunks ---
         self._global_customer_ids = set()
         self._global_staff_ids = set()
+        
+        # Business metrics manager for publishing aggregated metrics every 5 minutes
+        self._business_metrics_manager_factory: Optional[BusinessMetricsManagerFactory] = None
+        self._business_metrics_manager: Optional[BUSINESS_METRICS_MANAGER] = None
+        self._business_metrics_manager_initialized: bool = False
+        
+        # --- Tracker and tracking state (for YOLOv8 frame-wise predictions) ---
+        self.tracker = None
+        self._total_frame_counter: int = 0
+        self._tracking_start_time: Optional[float] = None
+        
+        # Track ID merging/aliasing for consistent tracking across frames
+        self._track_aliases: Dict[Any, Any] = {}
+        self._canonical_tracks: Dict[Any, Dict[str, Any]] = {}
+        self._track_merge_iou_threshold: float = 0.05
+        self._track_merge_time_window: float = 7.0
+        
+        # Per-category tracking for staff and customers
+        self._per_category_total_track_ids: Dict[str, set] = {}
+        self._current_frame_track_ids: Dict[str, set] = {}
     
+    def _initialize_business_metrics_manager_once(self, config: CustomerServiceConfig) -> None:
+        """
+        Initialize business metrics manager ONCE with Redis OR Kafka clients (Environment based).
+        Called from process() on first invocation.
+        Uses config.session (existing session from pipeline) or creates from environment.
+        """
+        if self._business_metrics_manager_initialized:
+            return
+        
+        try:
+            self.logger.info("[BUSINESS_METRICS_MANAGER] Starting business metrics manager initialization for customer service...")
+            
+            # Create factory if not exists
+            if self._business_metrics_manager_factory is None:
+                self._business_metrics_manager_factory = BusinessMetricsManagerFactory(logger=self.logger)
+            
+            # Initialize using factory (handles session creation, Redis/Kafka setup)
+            # Aggregation interval: 300 seconds (5 minutes)
+            self._business_metrics_manager = self._business_metrics_manager_factory.initialize(
+                config,
+                aggregation_interval=300  # 5 minutes
+            )
+            
+            if self._business_metrics_manager:
+                self.logger.info("[BUSINESS_METRICS_MANAGER] ✓ Business metrics manager initialized successfully for customer service")
+            else:
+                self.logger.warning("[BUSINESS_METRICS_MANAGER] Business metrics manager not available, metrics won't be published")
+        
+        except Exception as e:
+            self.logger.error(f"[BUSINESS_METRICS_MANAGER] Business metrics manager initialization failed: {e}", exc_info=True)
+        finally:
+            self._business_metrics_manager_initialized = True  # Mark as initialized (don't retry every frame)
+
+    def _apply_tracker(self, data: Any) -> Any:
+        """
+        Initialize and apply AdvancedTracker for YOLOv8 frame-wise predictions.
+        This adds track_id to detections for consistent tracking across frames.
+        
+        Args:
+            data: Processed detection data (list of detections or dict)
+            
+        Returns:
+            Data with track_ids assigned to detections
+        """
+        try:
+            from ..advanced_tracker import AdvancedTracker
+            from ..advanced_tracker.config import TrackerConfig
+            
+            # Initialize tracker once
+            if self.tracker is None:
+                tracker_config = TrackerConfig(
+                    track_high_thresh=0.4,
+                    track_low_thresh=0.05,
+                    new_track_thresh=0.3,
+                    match_thresh=0.8
+                )
+                self.tracker = AdvancedTracker(tracker_config)
+                self.logger.info("Initialized AdvancedTracker for Customer Service")
+            
+            # Apply tracker to get track_ids
+            tracked_data = self.tracker.update(data)
+            
+            # Update tracking state for consistent ID management
+            self._update_tracking_state(tracked_data)
+            self._total_frame_counter += 1
+            
+            return tracked_data
+            
+        except ImportError as e:
+            self.logger.warning(f"AdvancedTracker not available: {e}. Proceeding without tracking.")
+            return data
+        except Exception as e:
+            self.logger.warning(f"AdvancedTracker failed: {e}. Proceeding without tracking.")
+            return data
+    
+    def _update_tracking_state(self, detections: Any) -> None:
+        """
+        Update tracking state with current frame detections.
+        Handles track ID aliasing and per-category tracking.
+        
+        Args:
+            detections: List of detections or dict with detections
+        """
+        # Extract detection list from various formats
+        detection_list = []
+        if isinstance(detections, list):
+            detection_list = [d for d in detections if isinstance(d, dict)]
+        elif isinstance(detections, dict):
+            for key, value in detections.items():
+                if isinstance(value, list):
+                    detection_list.extend([d for d in value if isinstance(d, dict)])
+        
+        # Initialize per-category tracking if not exists
+        target_categories = ['person', 'staff', 'customer', 'employee']
+        if not self._per_category_total_track_ids:
+            self._per_category_total_track_ids = {cat: set() for cat in target_categories}
+        
+        self._current_frame_track_ids = {cat: set() for cat in target_categories}
+        
+        for det in detection_list:
+            cat = det.get("category", det.get("class", ""))
+            raw_track_id = det.get("track_id")
+            
+            if raw_track_id is None:
+                continue
+            
+            bbox = det.get("bounding_box", det.get("bbox"))
+            canonical_id = self._merge_or_register_track(raw_track_id, bbox)
+            det["track_id"] = canonical_id
+            
+            # Track by category
+            if cat in target_categories:
+                self._per_category_total_track_ids.setdefault(cat, set()).add(canonical_id)
+                self._current_frame_track_ids.setdefault(cat, set()).add(canonical_id)
+            else:
+                # Default to 'person' category for unknown categories
+                self._per_category_total_track_ids.setdefault('person', set()).add(canonical_id)
+                self._current_frame_track_ids.setdefault('person', set()).add(canonical_id)
+    
+    def _merge_or_register_track(self, raw_id: Any, bbox: Any) -> Any:
+        """
+        Merge or register a track ID to maintain consistent tracking.
+        Uses IoU-based matching to merge tracks that likely represent the same object.
+        
+        Args:
+            raw_id: Raw track ID from tracker
+            bbox: Bounding box of the detection
+            
+        Returns:
+            Canonical track ID (either merged or new)
+        """
+        if raw_id is None or bbox is None:
+            return raw_id
+        
+        now = time.time()
+        
+        # Check if this raw_id is already aliased
+        if raw_id in self._track_aliases:
+            canonical_id = self._track_aliases[raw_id]
+            track_info = self._canonical_tracks.get(canonical_id)
+            if track_info is not None:
+                track_info["last_bbox"] = bbox
+                track_info["last_update"] = now
+                track_info["raw_ids"].add(raw_id)
+            return canonical_id
+        
+        # Try to find a matching canonical track by IoU
+        for canonical_id, info in self._canonical_tracks.items():
+            if now - info["last_update"] > self._track_merge_time_window:
+                continue
+            iou = self._compute_iou(bbox, info["last_bbox"])
+            if iou >= self._track_merge_iou_threshold:
+                self._track_aliases[raw_id] = canonical_id
+                info["last_bbox"] = bbox
+                info["last_update"] = now
+                info["raw_ids"].add(raw_id)
+                return canonical_id
+        
+        # No match found, register as new canonical track
+        canonical_id = raw_id
+        self._track_aliases[raw_id] = canonical_id
+        self._canonical_tracks[canonical_id] = {
+            "last_bbox": bbox,
+            "last_update": now,
+            "raw_ids": {raw_id},
+        }
+        return canonical_id
+    
+    def _compute_iou(self, box1: Any, box2: Any) -> float:
+        """
+        Compute Intersection over Union (IoU) between two bounding boxes.
+        Handles various bbox formats (list, dict with xmin/ymin/xmax/ymax or x1/y1/x2/y2).
+        
+        Args:
+            box1: First bounding box
+            box2: Second bounding box
+            
+        Returns:
+            IoU value between 0.0 and 1.0
+        """
+        def _bbox_to_list(bbox):
+            if bbox is None:
+                return []
+            if isinstance(bbox, list):
+                return bbox[:4] if len(bbox) >= 4 else []
+            if isinstance(bbox, dict):
+                if "xmin" in bbox:
+                    return [bbox.get("xmin", 0), bbox.get("ymin", 0), 
+                            bbox.get("xmax", 0), bbox.get("ymax", 0)]
+                if "x1" in bbox:
+                    return [bbox.get("x1", 0), bbox.get("y1", 0), 
+                            bbox.get("x2", 0), bbox.get("y2", 0)]
+                # Try to extract values from dict
+                values = [v for v in bbox.values() if isinstance(v, (int, float))]
+                return values[:4] if len(values) >= 4 else []
+            return []
+        
+        l1 = _bbox_to_list(box1)
+        l2 = _bbox_to_list(box2)
+        
+        if len(l1) < 4 or len(l2) < 4:
+            return 0.0
+        
+        x1_min, y1_min, x1_max, y1_max = l1
+        x2_min, y2_min, x2_max, y2_max = l2
+        
+        # Ensure proper ordering
+        x1_min, x1_max = min(x1_min, x1_max), max(x1_min, x1_max)
+        y1_min, y1_max = min(y1_min, y1_max), max(y1_min, y1_max)
+        x2_min, x2_max = min(x2_min, x2_max), max(x2_min, x2_max)
+        y2_min, y2_max = min(y2_min, y2_max), max(y2_min, y2_max)
+        
+        # Calculate intersection
+        inter_x_min = max(x1_min, x2_min)
+        inter_y_min = max(y1_min, y2_min)
+        inter_x_max = min(x1_max, x2_max)
+        inter_y_max = min(y1_max, y2_max)
+        
+        inter_w = max(0.0, inter_x_max - inter_x_min)
+        inter_h = max(0.0, inter_y_max - inter_y_min)
+        inter_area = inter_w * inter_h
+        
+        # Calculate union
+        area1 = (x1_max - x1_min) * (y1_max - y1_min)
+        area2 = (x2_max - x2_min) * (y2_max - y2_min)
+        union_area = area1 + area2 - inter_area
+        
+        return (inter_area / union_area) if union_area > 0 else 0.0
+    
+    def get_total_counts(self) -> Dict[str, int]:
+        """
+        Get total unique counts per category across all processed frames.
+        
+        Returns:
+            Dictionary mapping category to unique count
+        """
+        return {cat: len(ids) for cat, ids in self._per_category_total_track_ids.items()}
+    
+    def reset_tracking_state(self) -> None:
+        """
+        Reset all tracking state. Useful for starting a new session.
+        """
+        self.tracker = None
+        self._total_frame_counter = 0
+        self._tracking_start_time = None
+        self._track_aliases = {}
+        self._canonical_tracks = {}
+        self._per_category_total_track_ids = {}
+        self._current_frame_track_ids = {}
+        self._global_customer_ids = set()
+        self._global_staff_ids = set()
+        self.logger.info("Tracking state reset for Customer Service")
+
+    def _send_metrics_to_manager(
+        self, 
+        business_metrics: Dict[str, Any], 
+        stream_info: Optional[Any] = None
+    ) -> None:
+        """
+        Send business metrics to the business metrics manager for aggregation and publishing.
+        
+        The business metrics manager will:
+        1. Aggregate metrics for 5 minutes (300 seconds)
+        2. Publish aggregated metrics (mean/min/max/sum) to output topic
+        3. Reset all values after publishing
+        
+        Args:
+            business_metrics: Business metrics dictionary from _calculate_business_metrics
+            stream_info: Stream metadata containing camera info
+        """
+        if not self._business_metrics_manager:
+            self.logger.debug("[BUSINESS_METRICS_MANAGER] No business metrics manager available, skipping")
+            return
+        
+        # Extract camera_id from stream_info
+        camera_id = ""
+        if stream_info:
+            camera_info = stream_info.get("camera_info", {}) if isinstance(stream_info, dict) else {}
+            camera_id = camera_info.get("camera_id", "")
+            if not camera_id:
+                camera_id = stream_info.get("camera_id", "") if isinstance(stream_info, dict) else ""
+        
+        if not camera_id:
+            # Fallback to a default identifier
+            camera_id = "default_camera"
+            self.logger.debug(f"[BUSINESS_METRICS_MANAGER] No camera_id found, using default: {camera_id}")
+        
+        try:
+            # Process the metrics through the manager
+            published = self._business_metrics_manager.process_metrics(
+                camera_id=camera_id,
+                metrics_data=business_metrics,
+                stream_info=stream_info
+            )
+            
+            if published:
+                self.logger.info(f"[BUSINESS_METRICS_MANAGER] Metrics published for camera: {camera_id}")
+        except Exception as e:
+            self.logger.error(f"[BUSINESS_METRICS_MANAGER] Error sending metrics to manager: {e}", exc_info=True)
+
     def get_config_schema(self) -> Dict[str, Any]:
         """Get configuration schema for customer service."""
         return {
@@ -210,6 +538,10 @@ class CustomerServiceUseCase(BaseProcessor):
             # Initialize processing context if not provided
             if context is None:
                 context = ProcessingContext()
+            config.enable_tracking=True
+            # Initialize business metrics manager once (for publishing aggregated metrics)
+            if not self._business_metrics_manager_initialized:
+                self._initialize_business_metrics_manager_once(config)
             
             # Detect input format
             input_format = match_results_structure(data)
@@ -230,6 +562,14 @@ class CustomerServiceUseCase(BaseProcessor):
                 processed_data = apply_category_mapping(processed_data, config.index_to_category)
                 self.logger.debug("Applied category mapping")
             
+            # Step 2.5: Initialize and apply tracker for YOLOv8 frame-wise predictions
+            # Only apply tracker if tracking is enabled in config
+            
+            if config.enable_tracking:
+                processed_data = self._apply_tracker(processed_data)
+            else:
+                self.logger.debug("Tracking disabled in config, skipping tracker application")
+            
             # Step 3: Extract detections and assign 'person' by area if needed
             detections = self._extract_detections(processed_data)
             assign_person_by_area(
@@ -268,6 +608,11 @@ class CustomerServiceUseCase(BaseProcessor):
                 area_analysis, service_interactions, customer_analytics, 
                 staff_analytics, config
             )
+            
+            # Step 8.5: Send business metrics to manager for aggregation and publishing
+            # The manager aggregates for 5 minutes and publishes mean/min/max/sum
+            if business_metrics:
+                self._send_metrics_to_manager(business_metrics, stream_info)
 
             # Step 9: Generate insights and alerts
             insights = self._generate_insights(
@@ -447,23 +792,25 @@ class CustomerServiceUseCase(BaseProcessor):
     def _count_people_in_area(self, detections: List[Dict], polygon: List[List[float]]) -> int:
         """
         Count unique people (by track_id) in a specific area defined by polygon.
-        Previous logic (per-frame count) is commented out below.
+        Falls back to raw count if no track_ids are available.
         """
-        # count = 0
-        # for detection in detections:
-        #     center = get_bbox_center(detection.get('bbox', detection.get('bounding_box', {})))
-        #     if center and point_in_polygon(center, polygon):
-        #         count += 1
-        # return count
-
         track_ids = set()
+        count_without_track = 0
+        
         for detection in detections:
             center = get_bbox_center(detection.get('bbox', detection.get('bounding_box', {})))
             if center and point_in_polygon(center, polygon):
                 track_id = detection.get('track_id')
                 if track_id is not None:
                     track_ids.add(track_id)
-        return len(track_ids)
+                else:
+                    # Fallback: count detections without track_id
+                    count_without_track += 1
+        
+        # If we have track_ids, use unique count; otherwise fall back to raw count
+        if track_ids:
+            return len(track_ids)
+        return count_without_track
     
     def _analyze_service_interactions(self, staff_detections: List[Dict], customer_detections: List[Dict],
                                     config: CustomerServiceConfig) -> List[Dict]: