matrice-analytics 0.1.60__py3-none-any.whl

matrice_analytics/post_processing/advanced_tracker/tracker.py

@@ -0,0 +1,367 @@
+"""
+Advanced tracker implementation.
+
+This module provides the AdvancedTracker class that implements BYTETracker-like
+functionality for object tracking with support for various input formats.
+"""
+
+from typing import Any, List, Optional, Tuple, Union, Dict
+import numpy as np
+import logging
+
+from .base import BaseTrack, TrackState
+from .config import TrackerConfig
+from .kalman_filter import KalmanFilterXYAH
+from .strack import STrack
+from .matching import linear_assignment, iou_distance, fuse_score
+
+logger = logging.getLogger(__name__)
+
+
+class AdvancedTracker:
+    """
+    AdvancedTracker: A tracking algorithm similar to BYTETracker for object detection and tracking.
+
+    This class encapsulates the functionality for initializing, updating, and managing the tracks for detected objects in a
+    video sequence. It maintains the state of tracked, lost, and removed tracks over frames, utilizes Kalman filtering for
+    predicting the new object locations, and performs data association.
+
+    Attributes:
+        tracked_stracks (List[STrack]): List of successfully activated tracks.
+        lost_stracks (List[STrack]): List of lost tracks.
+        removed_stracks (List[STrack]): List of removed tracks.
+        frame_id (int): The current frame ID.
+        config (TrackerConfig): Tracker configuration.
+        max_time_lost (int): The maximum frames for a track to be considered as 'lost'.
+        kalman_filter (KalmanFilterXYAH): Kalman Filter object.
+    """
+
+    def __init__(self, config: TrackerConfig):
+        """
+        Initialize an AdvancedTracker instance for object tracking.
+
+        Args:
+            config (TrackerConfig): Tracker configuration object.
+        """
+        self.tracked_stracks = []  # type: List[STrack]
+        self.lost_stracks = []  # type: List[STrack]
+        self.removed_stracks = []  # type: List[STrack]
+
+        self.frame_id = 0
+        self.config = config
+        self.max_time_lost = config.max_time_lost
+        self.kalman_filter = self.get_kalmanfilter()
+        self.reset_id()
+
+    def update(self, detections: Union[List[Dict], Dict[str, List[Dict]]], 
+               img: Optional[np.ndarray] = None) -> Union[List[Dict], Dict[str, List[Dict]]]:
+        """
+        Update the tracker with new detections and return the current list of tracked objects.
+
+        Args:
+            detections: Detection results in various formats:
+                - List[Dict]: Single frame detections
+                - Dict[str, List[Dict]]: Multi-frame detections with frame keys
+            img: Optional image for motion compensation
+
+        Returns:
+            Tracking results in the same format as input
+        """
+        self.frame_id += 1
+        
+        # Handle different input formats
+        if isinstance(detections, dict):
+            # Multi-frame format
+            return self._update_multi_frame(detections, img)
+        else:
+            # Single frame format
+            return self._update_single_frame(detections, img)
+
+    def _update_single_frame(self, detections: List[Dict], img: Optional[np.ndarray] = None) -> List[Dict]:
+        """Update tracker with single frame detections."""
+        # Convert detections to STrack format
+        stracks = self._convert_detections_to_stracks(detections)
+        
+        # Perform tracking update
+        tracked_objects = self._perform_tracking_update(stracks, img)
+        
+        # Convert back to detection format
+        return self._convert_stracks_to_detections(tracked_objects)
+
+    def _update_multi_frame(self, detections: Dict[str, List[Dict]], 
+                           img: Optional[np.ndarray] = None) -> Dict[str, List[Dict]]:
+        """Update tracker with multi-frame detections."""
+        results = {}
+        
+        for frame_key, frame_detections in detections.items():
+            # Convert frame detections to STrack format
+            stracks = self._convert_detections_to_stracks(frame_detections)
+            
+            # Perform tracking update
+            tracked_objects = self._perform_tracking_update(stracks, img)
+            
+            # Convert back to detection format
+            results[frame_key] = self._convert_stracks_to_detections(tracked_objects)
+        
+        return results
+
+    def _convert_detections_to_stracks(self, detections: List[Dict]) -> List[STrack]:
+        """Convert detection format to STrack objects."""
+        stracks = []
+        
+        for i, det in enumerate(detections):
+            # Extract bounding box
+            bbox = det.get('bounding_box', {})
+            if 'x' in bbox and 'y' in bbox and 'width' in bbox and 'height' in bbox:
+                # Center format
+                x, y, w, h = bbox['x'], bbox['y'], bbox['width'], bbox['height']
+            elif 'xmin' in bbox and 'ymin' in bbox and 'xmax' in bbox and 'ymax' in bbox:
+                # Corner format
+                x = (bbox['xmin'] + bbox['xmax']) / 2
+                y = (bbox['ymin'] + bbox['ymax']) / 2
+                w = bbox['xmax'] - bbox['xmin']
+                h = bbox['ymax'] - bbox['ymin']
+            else:
+                # Try to extract from any format
+                values = list(bbox.values())
+                if len(values) >= 4:
+                    x, y, w, h = values[0], values[1], values[2], values[3]
+                else:
+                    continue
+            
+            # Extract other properties
+            score = det.get('confidence', 0.0)
+            category = det.get('category', 'unknown')
+            
+            # Create STrack
+            xywh = [x, y, w, h, i]  # Add index as last element
+            strack = STrack(xywh, score, category)
+            
+            # CRITICAL FIX: Store the original detection data to preserve all fields
+            # This ensures face recognition fields (embedding, landmarks, etc.) are preserved
+            strack.original_detection = det.copy()
+            
+            stracks.append(strack)
+        
+        return stracks
+
+    def _convert_stracks_to_detections(self, stracks: List[STrack]) -> List[Dict]:
+        """Convert STrack objects back to detection format."""
+        detections = []
+        
+        for strack in stracks:
+            if strack.is_activated:
+                # Get bounding box in xyxy format
+                xyxy = strack.xyxy
+                
+                # CRITICAL FIX: Start with original detection data to preserve all fields
+                if hasattr(strack, 'original_detection') and strack.original_detection:
+                    # Start with the original detection to preserve all face recognition fields
+                    detection = strack.original_detection.copy()
+                    
+                    # Update with tracking-specific fields
+                    detection['bounding_box'] = {
+                        'xmin': float(xyxy[0]),
+                        'ymin': float(xyxy[1]),
+                        'xmax': float(xyxy[2]),
+                        'ymax': float(xyxy[3])
+                    }
+                    detection['confidence'] = float(strack.score)
+                    detection['category'] = strack.cls
+                    detection['track_id'] = int(strack.track_id)
+                    detection['frame_id'] = int(strack.frame_id)
+                else:
+                    # Fallback to minimal detection if original data not available
+                    detection = {
+                        'bounding_box': {
+                            'xmin': float(xyxy[0]),
+                            'ymin': float(xyxy[1]),
+                            'xmax': float(xyxy[2]),
+                            'ymax': float(xyxy[3])
+                        },
+                        'confidence': float(strack.score),
+                        'category': strack.cls,
+                        'track_id': int(strack.track_id),
+                        'frame_id': int(strack.frame_id)
+                    }
+                
+                detections.append(detection)
+        
+        return detections
+
+    def _perform_tracking_update(self, detections: List[STrack], 
+                                img: Optional[np.ndarray] = None) -> List[STrack]:
+        """Perform the core tracking update algorithm."""
+        activated_stracks = []
+        refind_stracks = []
+        lost_stracks = []
+        removed_stracks = []
+
+        # Separate high and low confidence detections
+        scores = np.array([det.score for det in detections])
+        remain_inds = scores >= self.config.track_high_thresh
+        inds_low = scores > self.config.track_low_thresh
+        inds_high = scores < self.config.track_high_thresh
+
+        inds_second = inds_low & inds_high
+        dets_second = [detections[i] for i in range(len(detections)) if inds_second[i]]
+        dets = [detections[i] for i in range(len(detections)) if remain_inds[i]]
+        scores_keep = scores[remain_inds]
+        scores_second = scores[inds_second]
+
+        # Step 1: First association, with high score detection boxes
+        unconfirmed = []
+        tracked_stracks = []
+        for track in self.tracked_stracks:
+            if not track.is_activated:
+                unconfirmed.append(track)
+            else:
+                tracked_stracks.append(track)
+
+        # Predict the current location with KF
+        strack_pool = self.joint_stracks(tracked_stracks, self.lost_stracks)
+        self.multi_predict(strack_pool)
+
+        # Calculate distances and perform matching
+        dists = self.get_dists(strack_pool, dets)
+        matches, u_track, u_detection = linear_assignment(dists, thresh=self.config.match_thresh)
+
+        for itracked, idet in matches:
+            track = strack_pool[itracked]
+            det = dets[idet]
+            if track.state == TrackState.Tracked:
+                track.update(det, self.frame_id)
+                activated_stracks.append(track)
+            else:
+                track.re_activate(det, self.frame_id, new_id=False)
+                refind_stracks.append(track)
+
+        # Step 2: Second association, with low score detection boxes
+        r_tracked_stracks = [strack_pool[i] for i in u_track if strack_pool[i].state == TrackState.Tracked]
+        dists = iou_distance(r_tracked_stracks, dets_second)
+        matches, u_track, u_detection_second = linear_assignment(dists, thresh=0.5)
+
+        for itracked, idet in matches:
+            track = r_tracked_stracks[itracked]
+            det = dets_second[idet]
+            if track.state == TrackState.Tracked:
+                track.update(det, self.frame_id)
+                activated_stracks.append(track)
+            else:
+                track.re_activate(det, self.frame_id, new_id=False)
+                refind_stracks.append(track)
+
+        for it in u_track:
+            track = r_tracked_stracks[it]
+            if track.state != TrackState.Lost:
+                track.mark_lost()
+                lost_stracks.append(track)
+
+        # Step 3: Deal with unconfirmed tracks
+        detections = [dets[i] for i in u_detection]
+        dists = self.get_dists(unconfirmed, detections)
+        matches, u_unconfirmed, u_detection = linear_assignment(dists, thresh=0.7)
+
+        for itracked, idet in matches:
+            unconfirmed[itracked].update(detections[idet], self.frame_id)
+            activated_stracks.append(unconfirmed[itracked])
+
+        for it in u_unconfirmed:
+            track = unconfirmed[it]
+            track.mark_removed()
+            removed_stracks.append(track)
+
+        # Step 4: Init new stracks
+        for inew in u_detection:
+            track = detections[inew]
+            if track.score < self.config.new_track_thresh:
+                continue
+            track.activate(self.kalman_filter, self.frame_id)
+            activated_stracks.append(track)
+
+        # Step 5: Update state
+        for track in self.lost_stracks:
+            if self.frame_id - track.end_frame > self.max_time_lost:
+                track.mark_removed()
+                removed_stracks.append(track)
+
+        self.tracked_stracks = [t for t in self.tracked_stracks if t.state == TrackState.Tracked]
+        self.tracked_stracks = self.joint_stracks(self.tracked_stracks, activated_stracks)
+        self.tracked_stracks = self.joint_stracks(self.tracked_stracks, refind_stracks)
+        self.lost_stracks = self.sub_stracks(self.lost_stracks, self.tracked_stracks)
+        self.lost_stracks.extend(lost_stracks)
+        self.lost_stracks = self.sub_stracks(self.lost_stracks, self.removed_stracks)
+        self.tracked_stracks, self.lost_stracks = self.remove_duplicate_stracks(self.tracked_stracks, self.lost_stracks)
+        self.removed_stracks.extend(removed_stracks)
+        
+        if len(self.removed_stracks) > 1000:
+            self.removed_stracks = self.removed_stracks[-999:]
+
+        return [x for x in self.tracked_stracks if x.is_activated]
+
+    def get_kalmanfilter(self) -> KalmanFilterXYAH:
+        """Return a Kalman filter object for tracking bounding boxes using KalmanFilterXYAH."""
+        return KalmanFilterXYAH()
+
+    def get_dists(self, tracks: List[STrack], detections: List[STrack]) -> np.ndarray:
+        """Calculate the distance between tracks and detections using IoU and optionally fuse scores."""
+        dists = iou_distance(tracks, detections)
+        if self.config.fuse_score:
+            dists = fuse_score(dists, detections)
+        return dists
+
+    def multi_predict(self, tracks: List[STrack]):
+        """Predict the next states for multiple tracks using Kalman filter."""
+        STrack.multi_predict(tracks)
+
+    @staticmethod
+    def reset_id():
+        """Reset the ID counter for STrack instances to ensure unique track IDs across tracking sessions."""
+        STrack.reset_id()
+
+    def reset(self):
+        """Reset the tracker by clearing all tracked, lost, and removed tracks and reinitializing the Kalman filter."""
+        self.tracked_stracks = []
+        self.lost_stracks = []
+        self.removed_stracks = []
+        self.frame_id = 0
+        self.kalman_filter = self.get_kalmanfilter()
+        self.reset_id()
+
+    @staticmethod
+    def joint_stracks(tlista: List[STrack], tlistb: List[STrack]) -> List[STrack]:
+        """Combine two lists of STrack objects into a single list, ensuring no duplicates based on track IDs."""
+        exists = {}
+        res = []
+        for t in tlista:
+            exists[t.track_id] = 1
+            res.append(t)
+        for t in tlistb:
+            tid = t.track_id
+            if not exists.get(tid, 0):
+                exists[tid] = 1
+                res.append(t)
+        return res
+
+    @staticmethod
+    def sub_stracks(tlista: List[STrack], tlistb: List[STrack]) -> List[STrack]:
+        """Filter out the stracks present in the second list from the first list."""
+        track_ids_b = {t.track_id for t in tlistb}
+        return [t for t in tlista if t.track_id not in track_ids_b]
+
+    @staticmethod
+    def remove_duplicate_stracks(stracksa: List[STrack], stracksb: List[STrack]) -> Tuple[List[STrack], List[STrack]]:
+        """Remove duplicate stracks from two lists based on Intersection over Union (IoU) distance."""
+        pdist = iou_distance(stracksa, stracksb)
+        pairs = np.where(pdist < 0.15)
+        dupa, dupb = [], []
+        for p, q in zip(*pairs):
+            timep = stracksa[p].frame_id - stracksa[p].start_frame
+            timeq = stracksb[q].frame_id - stracksb[q].start_frame
+            if timep > timeq:
+                dupb.append(q)
+            else:
+                dupa.append(p)
+        resa = [t for i, t in enumerate(stracksa) if i not in dupa]
+        resb = [t for i, t in enumerate(stracksb) if i not in dupb]
+        return resa, resb 

matrice_analytics/post_processing/config.py

@@ -0,0 +1,146 @@
+APP_NAME_TO_USECASE = {
+    "people_counting": "people_counting",
+    "drone_traffic_monitoring": "drone_traffic_monitoring",
+    "intrusion_detection": "intrusion_detection",
+    "proximity_detection": "proximity_detection",
+    "mask_detection": "mask_detection",
+    "pipeline_detection": "pipeline_detection",
+    "vehicle_monitoring": "vehicle_monitoring",
+    "Vehicle Type Monitoring": "vehicle_monitoring",
+    "weapon_detection": "weapon_detection",
+    "traffic_sign_monitoring": "traffic_sign_monitoring",
+    "flare_analysis": "flare_analysis",
+    "ppe_compliance": "ppe_compliance",
+    "advanced_customer_service": "advanced_customer_service",
+    "assembly_line_detection": "assembly_line_detection",
+    "crop_weed_detection"  : "crop_weed_detection",
+    "emergency_vehicle_detection": "emergency_vehicle_detection",
+    "fashion_detection": "fashion_detection",
+    "gender_detection": "gender_detection",
+    "price_tag_detection": "price_tag_detection",
+    "windmill_maintenance": "windmill_maintenance",
+    "underwater_pollution_detection": "underwater_pollution_detection",
+    "solar_panel": "solar_panel",
+    "face_emotion": "face_emotion",
+    "pedestrian_detection": "pedestrian_detection",
+    "warehouse_object_segmentation": "warehouse_object_segmentation",
+    "flower_segmentation": "flower_segmentation",
+    "shopping_cart_analysis": "shopping_cart_analysis",
+    "car_part_segmentation": "car_part_segmentation",
+    "weld_defect_detection" : "weld_defect_detection",
+    "fruit_monitoring" : "fruit_monitoring",
+    "concrete_crack_detection": "concrete_crack_detection",
+    "lane_detection" : "lane_detection",
+    "shelf_inventory" :"shelf_inventory",
+    "smoker_detection": "smoker_detection",
+    "age_detection": "age_detection",
+    "defect_detection_products": "defect_detection_products",
+    "parking_space_detection": "parking_space_detection",
+    "car_damage_detection": "car_damage_detection",
+    "license_plate_detection": "license_plate_detection",
+    "shoplifting_detection": "shoplifting_detection",
+    "cardiomegaly_classification": "cardiomegaly_classification",
+    "road_traffic_density": "road_traffic_density",
+    "histopathological_cancer_detection" : "histopathological_cancer_detection",
+    "road_view_segmentation": "road_view_segmentation",
+    "face_recognition": "face_recognition",
+    "drowsy_driver_detection": "drowsy_driver_detection",
+    "waterbody_segmentation": "waterbody_segmentation",
+    "litter_detection" : "litter_detection",
+    "leak_detection": "leak_detection",
+    "Fire Safety Monitoring": "fire_smoke_detection",
+    "human_activity_recognition": "human_activity_recognition",
+    "abandoned_object_detection" : "abandoned_object_detection",
+    "gas_leak_detection": "gas_leak_detection",
+    "color_detection": "color_detection",
+    "Color Detection": "color_detection",
+    "License Plate Recognition" : "license_plate_monitor",
+    "License Plate Monitoring" : "license_plate_monitor",
+    "cell_microscopy_segmentation": "cell_microscopy_segmentation",
+    "Dwell Detection": "dwell",
+    "age_gender_detection": "age_gender_detection",
+    "People Tracking" : "people_tracking",
+    "wildlife_monitoring": "wildlife_monitoring",
+    "pcb_defect_detection": "pcb_defect_detection",
+    "underground_pipeline_defect" : "underground_pipeline_defect",
+    "suspicious_activity_detection": "suspicious_activity_detection",
+    "natural_disaster_detection": "natural_disaster_detection",
+}
+
+APP_NAME_TO_CATEGORY = {
+    "people_counting": "general",
+    "drone_traffic_monitoring": "traffic",
+    "intrusion_detection": "security",
+    "proximity_detection": "security",
+    "mask_detection": "mask_detection",
+    "pipeline_detection": "pipeline_detection",
+    "vehicle_monitoring": "traffic",
+    "Vehicle Type Monitoring": "traffic",
+    "weapon_detection": "security",
+    "traffic_sign_monitoring": "traffic",
+    "flare_analysis": "flare_detection",
+    "ppe_compliance": "security",
+    "advanced_customer_service": "sales",
+    "assembly_line_detection": "manufacturing",
+    "crop_weed_detection": "agriculture",
+    "emergency_vehicle_detection": "traffic",
+    "fashion_detection": "retail",
+    "gender_detection": "general",
+    "price_tag_detection": "retail",
+    "windmill_maintenance": "windmill_maintenance",
+    "underwater_pollution_detection": "environmental",
+    "solar_panel": "energy",
+    "face_emotion": "general",
+    "pedestrian_detection": "pedestrian",
+    "warehouse_object_segmentation": "retail",
+    "flower_segmentation": "agriculture",
+    "shopping_cart_analysis": "retail",
+    "car_part_segmentation": "automobile",
+    "weld_defect_detection" : "weld",
+    "fruit_monitoring" : "agriculture",
+    "concrete_crack_detection": "general",
+    "lane_detection" : "traffic",
+    "shelf_inventory" : "retail",
+    "smoker_detection": "general",
+    "age_detection": "general",
+    "defect_detection_products": "retail",
+    "parking_space_detection": "parking_space",
+    "car_damage_detection": "car_damage",
+    "license_plate_detection": "license_plate",
+    "shoplifting_detection": "security",
+    "cardiomegaly_classification": "healthcare",
+    "road_traffic_density": "automobile",
+    "histopathological_cancer_detection" : "healthcare",
+    "road_view_segmentation": "automobile",
+    "face_recognition": "security",
+    "drowsy_driver_detection": "automobile",
+    "waterbody_segmentation": "agriculture",
+    "litter_detection" : "litter_detection",
+    "leak_detection": "oil_gas",
+    "Fire Safety Monitoring": "hazard",
+    "human_activity_recognition": "general",
+    "abandoned_object_detection" : "security",
+    "gas_leak_detection": "oil_gas",
+    "color_detection": "visual_appearance",
+    "Color Detection": "visual_appearance",
+    "License Plate Recognition" : "license_plate_monitor",
+    "License Plate Monitoring" : "license_plate_monitor",
+    "cell_microscopy_segmentation" : "healthcare",
+    "Dwell Detection": "general",
+    "age_gender_detection": "age_gender_detection",
+    "People Tracking" : "general",
+    
+    "wildlife_monitoring": "environmental",
+    "pcb_defect_detection": "manufacturing",
+    "underground_pipeline_defect" : "general",
+    "suspicious_activity_detection": "security",
+    "natural_disaster_detection": "environmental",
+}
+
+def get_usecase_from_app_name(app_name: str) -> str:
+    normalized_app_name = app_name.lower().replace(" ", "_").replace("-", "_")
+    return APP_NAME_TO_USECASE.get(app_name, APP_NAME_TO_USECASE.get(normalized_app_name))
+
+def get_category_from_app_name(app_name: str) -> str:
+    normalized_app_name = app_name.lower().replace(" ", "_").replace("-", "_")
+    return APP_NAME_TO_CATEGORY.get(app_name, APP_NAME_TO_CATEGORY.get(normalized_app_name))

matrice_analytics/post_processing/core/__init__.py

@@ -0,0 +1,63 @@
+"""
+Core components for post-processing.
+
+This module contains core base classes and configuration utilities.
+Note: Use case imports have been moved to avoid circular imports.
+"""
+
+# Core components that don't create circular imports
+from .base import (
+    ProcessingResult, 
+    ProcessingContext, 
+    ProcessingStatus,
+    ResultFormat,
+    BaseProcessor,
+    BaseUseCase,
+    ProcessorRegistry,
+    registry
+)
+
+from .config import (
+    BaseConfig,
+    PeopleCountingConfig,
+    CustomerServiceConfig,
+    IntrusionConfig,
+    ZoneConfig,
+    TrackingConfig,
+    AlertConfig,
+    ConfigManager,
+    config_manager,
+    ConfigValidationError,
+    PeopleTrackingConfig
+)
+
+# Note: Use case imports have been removed from this file to avoid circular imports.
+# Use cases should be imported directly from their respective modules in the usecases package.
+
+
+# Export only core components to avoid circular imports
+__all__ = [
+    # Base classes
+    'ProcessingResult',
+    'ProcessingContext', 
+    'ProcessingStatus',
+    'ResultFormat',
+    'BaseProcessor',
+    'BaseUseCase',
+    'ProcessorRegistry',
+    'registry',
+    
+    # Configuration classes
+    'BaseConfig',
+    'PeopleCountingConfig',
+    'IntrusionConfig',
+    'ProximityConfig',
+    'CustomerServiceConfig',
+    'ZoneConfig',
+    'TrackingConfig',
+    'AlertConfig',
+    'ConfigManager',
+    'config_manager',
+    'ConfigValidationError',
+    'PeopleTrackingConfig',
+]