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

matrice_analytics/post_processing/__init__.py

@@ -84,7 +84,8 @@ from .usecases.field_mapping import FieldMappingConfig, FieldMappingUseCase
 from .usecases.leaf_disease import LeafDiseaseDetectionConfig, LeafDiseaseDetectionUseCase
 from .usecases.parking import ParkingConfig
 from .usecases.abandoned_object_detection import AbandonedObjectConfig
-
+from .usecases.footfall import FootFallConfig
+from .usecases.vehicle_monitoring import VehicleMonitoringConfig
 
 from .usecases.weld_defect_detection import WeldDefectConfig
 from .usecases.weapon_detection import WeaponDetectionConfig
@@ -128,6 +129,9 @@ from .usecases.pcb_defect_detection import PCBDefectConfig, PCBDefectUseCase
 from .usecases.underground_pipeline_defect_detection import UndergroundPipelineDefectConfig,UndergroundPipelineDefectUseCase
 from .usecases.suspicious_activity_detection import SusActivityConfig, SusActivityUseCase
 from .usecases.natural_disaster import NaturalDisasterConfig, NaturalDisasterUseCase
+from .usecases.footfall import FootFallUseCase
+from .usecases.vehicle_monitoring_parking_lot import VehicleMonitoringParkingLotUseCase, VehicleMonitoringParkingLotConfig
+from .usecases.vehicle_monitoring_drone_view import VehicleMonitoringDroneViewUseCase, VehicleMonitoringDroneViewConfig
 
 #Put all IMAGE based usecases here
 from .usecases.blood_cancer_detection_img import BloodCancerDetectionConfig, BloodCancerDetectionUseCase
@@ -205,6 +209,9 @@ from .usecases import (
 
     SusActivityUseCase,
     NaturalDisasterUseCase,
+    FootFallUseCase,
+    VehicleMonitoringParkingLotUseCase,
+    VehicleMonitoringDroneViewUseCase,
 
     #Put all IMAGE based usecases here
     BloodCancerDetectionUseCase,
@@ -286,6 +293,9 @@ _pcb_defect_detection = PCBDefectUseCase()
 _underground_pipeline_defect = UndergroundPipelineDefectUseCase()
 _suspicious_activity_detection = SusActivityUseCase()
 _natural_disaster = NaturalDisasterUseCase()
+_footfall = FootFallUseCase()
+_vehicle_monitoring_parking_lot = VehicleMonitoringParkingLotUseCase()
+_vehicle_monitoring_drone_view = VehicleMonitoringDroneViewUseCase()
 
 # Face recognition with embeddings
 _face_recognition = FaceRecognitionEmbeddingUseCase()
@@ -370,6 +380,9 @@ registry.register_use_case(_pcb_defect_detection.category, _pcb_defect_detection
 registry.register_use_case(_underground_pipeline_defect.category, _underground_pipeline_defect.name, UndergroundPipelineDefectUseCase)
 registry.register_use_case(_suspicious_activity_detection.category, _suspicious_activity_detection.name, SusActivityUseCase)
 registry.register_use_case(_natural_disaster.category, _natural_disaster.name, NaturalDisasterUseCase)
+registry.register_use_case(_footfall.category, _footfall.name, FaceEmotionUseCase)
+registry.register_use_case(_vehicle_monitoring_parking_lot.category, _vehicle_monitoring_parking_lot.name, VehicleMonitoringParkingLotUseCase)
+registry.register_use_case(_vehicle_monitoring_drone_view.category, _vehicle_monitoring_drone_view.name, VehicleMonitoringDroneViewUseCase)
 
 #Put all IMAGE based usecases here
 registry.register_use_case(_blood_cancer_detection.category, _blood_cancer_detection.name, BloodCancerDetectionUseCase)
@@ -574,7 +587,10 @@ __all__ = [
     'UndergroundPipelineDefectConfig',
     'SusActivityConfig',
     'NaturalDisasterConfig',
-    'VehiclePeopleDroneMonitoringConfig'
+    'VehiclePeopleDroneMonitoringConfig',
+    'FootFallConfig',
+    'VehicleMonitoringParkingLotConfig',
+    'VehicleMonitoringDroneViewConfig',
     #Put all IMAGE based usecase CONFIGS here
     'BloodCancerDetectionConfig',
     'SkinCancerClassificationConfig',
@@ -648,6 +664,9 @@ __all__ = [
     'UndergroundPipelineDefectUseCase',
     'SusActivityUseCase',
     'NaturalDisasterUseCase',
+    'FootFallUseCase',
+    'VehicleMonitoringParkingLotUseCase',
+    'VehicleMonitoringDroneViewUseCase',
 
     #Put all IMAGE based usecases here
     'BloodCancerDetectionUseCase',

matrice_analytics/post_processing/config.py

@@ -65,6 +65,9 @@ APP_NAME_TO_USECASE = {
     "underground_pipeline_defect" : "underground_pipeline_defect",
     "suspicious_activity_detection": "suspicious_activity_detection",
     "natural_disaster_detection": "natural_disaster_detection",
+    "Foot Fall": "footfall",
+    "vehicle_monitoring_parking_lot": "vehicle_monitoring_parking_lot",
+    "vehicle_monitoring_drone_view": "vehicle_monitoring_drone_view",
 }
 
 APP_NAME_TO_CATEGORY = {
@@ -135,6 +138,9 @@ APP_NAME_TO_CATEGORY = {
     "underground_pipeline_defect" : "general",
     "suspicious_activity_detection": "security",
     "natural_disaster_detection": "environmental",
+    "Foot Fall": "retail",
+    "vehicle_monitoring_parking_lot": "traffic",
+    "vehicle_monitoring_drone_view": "traffic",
 }
 
 def get_usecase_from_app_name(app_name: str) -> str:

matrice_analytics/post_processing/core/config.py

@@ -352,14 +352,19 @@ class AlertConfig:
 @dataclass
 class PeopleCountingConfig(BaseConfig):
     """Configuration for people counting use case."""
-    
+
     # Smoothing configuration
     enable_smoothing: bool = True
     smoothing_algorithm: str = "observability"  # "window" or "observability"
     smoothing_window_size: int = 20
     smoothing_cooldown_frames: int = 5
     smoothing_confidence_range_factor: float = 0.5
-    
+
+    # ====== PERFORMANCE: Tracker selection (both disabled by default for max throughput) ======
+    enable_advanced_tracker: bool = False  # Heavy O(n³) tracker - enable only when tracking quality is critical
+    enable_simple_tracker: bool = False    # Lightweight O(n) tracker - fast but no cross-frame persistence
+    # ====== END PERFORMANCE CONFIG ======
+
     # Zone configuration
     zone_config: Optional[ZoneConfig] = None
     
@@ -901,6 +906,9 @@ class ConfigManager:
             'underground_pipeline_defect' : None,
             'suspicious_activity_detection': None,
             'natural_disaster_detection': None,
+            'footfall': None,
+            'vehicle_monitoring_parking_lot': None,
+            'vehicle_monitoring_drone_view': None,
 
             #Put all image based usecases here::
             'blood_cancer_detection_img': None,
@@ -1405,7 +1413,31 @@ class ConfigManager:
             return NaturalDisasterConfig
         except ImportError:
             return None
-    
+        
+    def footfall_detection_config_class(self):
+        """Register a configuration class for a use case."""
+        try:
+            from ..usecases.footfall import FootFallConfig
+            return FootFallConfig
+        except ImportError:
+            return None
+        
+    def vehicle_monitoring_parking_lot_config_class(self):
+        """Register a configuration class for a use case."""
+        try:
+            from ..usecases.vehicle_monitoring_parking_lot import VehicleMonitoringParkingLotConfig
+            return VehicleMonitoringParkingLotConfig
+        except ImportError:
+            return None
+        
+    def vehicle_monitoring_drone_view_config_class(self):
+        """Register a configuration class for a use case."""
+        try:
+            from ..usecases.vehicle_monitoring_drone_view import VehicleMonitoringDroneViewConfig
+            return VehicleMonitoringDroneViewConfig
+        except ImportError:
+            return None
+        
     #put all image based usecases here::
     def blood_cancer_detection_config_class(self):
         """Register a configuration class for a use case."""
@@ -2684,6 +2716,54 @@ class ConfigManager:
                 **kwargs
             )
         
+        elif usecase == "footfall":
+            # Import here to avoid circular import
+            from ..usecases.footfall import FootFallConfig
+
+            # Handle nested configurations
+            alert_config = kwargs.pop("alert_config", None)
+            if alert_config and isinstance(alert_config, dict):
+                alert_config = AlertConfig(**alert_config)
+
+            config = FootFallConfig(
+                category=category or "retail",
+                usecase=usecase,
+                alert_config=alert_config,
+                **kwargs
+            )
+
+        elif usecase == "vehicle_monitoring_parking_lot":
+            # Import here to avoid circular import
+            from ..usecases.vehicle_monitoring_parking_lot import VehicleMonitoringParkingLotConfig
+
+            # Handle nested configurations
+            alert_config = kwargs.pop("alert_config", None)
+            if alert_config and isinstance(alert_config, dict):
+                alert_config = AlertConfig(**alert_config)
+
+            config = VehicleMonitoringParkingLotConfig(
+                category=category or "traffic",
+                usecase=usecase,
+                alert_config=alert_config,
+                **kwargs
+            )
+
+        elif usecase == "vehicle_monitoring_drone_view":
+            # Import here to avoid circular import
+            from ..usecases.vehicle_monitoring_drone_view import VehicleMonitoringDroneViewConfig
+
+            # Handle nested configurations
+            alert_config = kwargs.pop("alert_config", None)
+            if alert_config and isinstance(alert_config, dict):
+                alert_config = AlertConfig(**alert_config)
+
+            config = VehicleMonitoringDroneViewConfig(
+                category=category or "traffic",
+                usecase=usecase,
+                alert_config=alert_config,
+                **kwargs
+            )
+        
         #Add IMAGE based usecases here::
         elif usecase == "blood_cancer_detection_img":
             # Import here to avoid circular import
@@ -3234,6 +3314,25 @@ class ConfigManager:
             from ..usecases.natural_disaster import NaturalDisasterConfig
             default_config = NaturalDisasterConfig()
             return default_config.to_dict()
+
+        elif usecase == "footfall":
+            # Import here to avoid circular import
+            from ..usecases.footfall import FootFallConfig
+            default_config = FootFallConfig()
+            return default_config.to_dict()
+        
+        elif usecase == "vehicle_monitoring_parking_lot":
+            # Import here to avoid circular import
+            from ..usecases.vehicle_monitoring_parking_lot import VehicleMonitoringParkingLotConfig
+            default_config = VehicleMonitoringParkingLotConfig()
+            return default_config.to_dict()
+        
+        elif usecase == "vehicle_monitoring_drone_view":
+            # Import here to avoid circular import
+            from ..usecases.vehicle_monitoring_drone_view import VehicleMonitoringDroneViewConfig
+            default_config = VehicleMonitoringDroneViewConfig()
+            return default_config.to_dict()
+        
         
         elif usecase == "underground_pipeline_defect":
             # Import here to avoid circular import

matrice_analytics/post_processing/face_reg/face_recognition.py

@@ -82,6 +82,9 @@ from .face_recognition_client import FacialRecognitionClient
 from .people_activity_logging import PeopleActivityLogging
 from .embedding_manager import EmbeddingManager, EmbeddingConfig
 
+# Cache for location names to avoid repeated API calls
+_location_name_cache: Dict[str, str] = {}
+
 
 # ---- Lightweight identity tracking and temporal smoothing (adapted from compare_similarity.py) ---- #
 from collections import deque, defaultdict
@@ -386,8 +389,10 @@ class RedisFaceMatcher:
             if session is None:
                 return None
 
-            response = await asyncio.to_thread(
-                self._fetch_action_details_sync, session, action_id
+            # Use run_in_executor for Python 3.8 compatibility (asyncio.to_thread requires 3.9+)
+            loop = asyncio.get_running_loop()
+            response = await loop.run_in_executor(
+                None, self._fetch_action_details_sync, session, action_id
             )
             if not response or not response.get("success", False):
                 self.logger.warning(
@@ -1336,6 +1341,98 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
             self.logger.error(f"Error during use case initialization: {e}", exc_info=True)
             raise RuntimeError(f"Failed to initialize face recognition use case: {e}") from e
 
+    def _extract_camera_info_from_stream(self, stream_info: Optional[Dict[str, Any]]) -> Dict[str, str]:
+        """
+        Extract camera_name, camera_id, and location_id from stream_info.
+        
+        Args:
+            stream_info: Stream information dictionary
+            
+        Returns:
+            Dict with camera_name, camera_id, location_id
+        """
+        camera_name = ""
+        camera_id = ""
+        location_id = ""
+        
+        if not stream_info:
+            return {"camera_name": camera_name, "camera_id": camera_id, "location_id": location_id}
+        
+        # Extract camera_name from camera_info
+        camera_info = stream_info.get("camera_info", {})
+        if camera_info:
+            camera_name = camera_info.get("camera_name", "")
+            location_id = camera_info.get("location", "")
+        
+        # Extract camera_id from topic (format: {camera_id}_input_topic)
+        topic = stream_info.get("topic", "")
+        if topic and "_input_topic" in topic:
+            camera_id = topic.replace("_input_topic", "")
+        
+        self.logger.debug(f"Extracted camera info - camera_name: '{camera_name}', camera_id: '{camera_id}', location_id: '{location_id}'")
+        
+        return {"camera_name": camera_name, "camera_id": camera_id, "location_id": location_id}
+
+    async def _fetch_location_name(self, location_id: str) -> str:
+        """
+        Fetch location name from API using location_id.
+        
+        Args:
+            location_id: The location ID to look up
+            
+        Returns:
+            Location name string, or 'Entry Reception' as default if API fails
+        """
+        global _location_name_cache
+        default_location = "Entry Reception"
+        
+        if not location_id:
+            self.logger.debug(f"[LOCATION] No location_id provided, using default: '{default_location}'")
+            return default_location
+        
+        # Check cache first
+        if location_id in _location_name_cache:
+            cached_name = _location_name_cache[location_id]
+            self.logger.debug(f"[LOCATION] Using cached location name for '{location_id}': '{cached_name}'")
+            return cached_name
+        
+        # Need a session to make API call
+        if not self.face_client or not hasattr(self.face_client, 'session') or not self.face_client.session:
+            self.logger.warning(f"[LOCATION] No session available, using default: '{default_location}'")
+            return default_location
+        
+        try:
+            endpoint = f"/v1/inference/get_location/{location_id}"
+            self.logger.info(f"[LOCATION] Fetching location name from API: {endpoint}")
+            
+            response = self.face_client.session.rpc.get(endpoint)
+            
+            if response and isinstance(response, dict):
+                success = response.get("success", False)
+                if success:
+                    data = response.get("data", {})
+                    location_name = data.get("locationName", default_location)
+                    self.logger.info(f"[LOCATION] ✓ Fetched location name: '{location_name}' for location_id: '{location_id}'")
+                    
+                    # Cache the result
+                    _location_name_cache[location_id] = location_name
+                    return location_name
+                else:
+                    self.logger.warning(
+                        f"[LOCATION] API returned success=false for location_id '{location_id}': "
+                        f"{response.get('message', 'Unknown error')}"
+                    )
+            else:
+                self.logger.warning(f"[LOCATION] Invalid response format from API: {response}")
+                
+        except Exception as e:
+            self.logger.error(f"[LOCATION] Error fetching location name for '{location_id}': {e}", exc_info=True)
+        
+        # Use default on any failure
+        self.logger.info(f"[LOCATION] Using default location name: '{default_location}'")
+        _location_name_cache[location_id] = default_location
+        return default_location
+
     async def _get_facial_recognition_client(
         self, config: FaceRecognitionEmbeddingConfig
     ) -> FacialRecognitionClient:
@@ -1352,6 +1449,8 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
             secret_key = os.getenv("MATRICE_SECRET_ACCESS_KEY", "")
             project_id = os.getenv("MATRICE_PROJECT_ID", "")
             
+            self.logger.info(f"[PROJECT_ID] Initial project_id from env: '{project_id}'")
+            
             self.session1 = Session(
                 account_number=account_number,
                 access_key=access_key_id,
@@ -1362,6 +1461,19 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
                 server_id=config.facial_recognition_server_id, session=self.session1
             )
             self.logger.info("Face recognition client initialized")
+            
+            # After FacialRecognitionClient initialization, it may have fetched project_id from action details
+            # and updated MATRICE_PROJECT_ID env var. Update session1 with the correct project_id.
+            updated_project_id = self.face_client.project_id or os.getenv("MATRICE_PROJECT_ID", "")
+            if updated_project_id and updated_project_id != project_id:
+                self.logger.info(f"[PROJECT_ID] Project ID updated by FacialRecognitionClient: '{updated_project_id}'")
+                try:
+                    self.session1.update(updated_project_id)
+                    self.logger.info(f"[PROJECT_ID] Updated session1 with project_id: '{updated_project_id}'")
+                except Exception as e:
+                    self.logger.warning(f"[PROJECT_ID] Failed to update session1 with project_id: {e}")
+            elif updated_project_id:
+                self.logger.info(f"[PROJECT_ID] Using project_id: '{updated_project_id}'")
 
             # Call update_deployment if deployment_id is provided
             if config.deployment_id:
@@ -1415,6 +1527,9 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
         """
         processing_start = time.time()
         # Ensure config is correct type
+        self.logger.info(f"[CONFIG-PRINT]-------------------------- {config} --------------------------")
+        self.logger.info(f"[STREAM-PRINT]-------------------------- {stream_info} --------------------------")
+        
         if not isinstance(config, FaceRecognitionEmbeddingConfig):
             return self.create_error_result(
                 "Invalid config type",
@@ -1546,6 +1661,16 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
         current_frame_staff_details = {}
 
 
+        # Extract camera info and fetch location name
+        camera_info_extracted = self._extract_camera_info_from_stream(stream_info)
+        camera_name = camera_info_extracted.get("camera_name", "")
+        camera_id = camera_info_extracted.get("camera_id", "")
+        location_id = camera_info_extracted.get("location_id", "")
+        
+        # Fetch actual location name from API
+        location_name = await self._fetch_location_name(location_id)
+        self.logger.debug(f"Using location_name: '{location_name}', camera_name: '{camera_name}', camera_id: '{camera_id}'")
+
         # Process face recognition for each detection (if enabled)
         if config.enable_face_recognition:
             # Additional safety check: verify embeddings are still loaded and ready
@@ -1562,7 +1687,8 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
             #     )
             
             face_recognition_result = await self._process_face_recognition(
-                processed_data, config, stream_info, input_bytes
+                processed_data, config, stream_info, input_bytes,
+                camera_name=camera_name, camera_id=camera_id, location_name=location_name
             )
             processed_data, current_recognized_count, current_unknown_count, recognized_persons, current_frame_staff_details = face_recognition_result
         else:
@@ -1753,6 +1879,9 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
         config: FaceRecognitionEmbeddingConfig,
         stream_info: Optional[Dict[str, Any]] = None,
         input_bytes: Optional[bytes] = None,
+        camera_name: str = "",
+        camera_id: str = "",
+        location_name: str = "",
     ) -> List[Dict]:
         """Process face recognition for each detection with embeddings"""
 
@@ -1789,10 +1918,8 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
                 )
             self._frame_warning_logged = True
 
-        # Get location from stream_info
-        location = (
-            stream_info.get("camera_location", "unknown") if stream_info else "unknown"
-        )
+        # Use the location_name passed from process() (fetched from API)
+        location = location_name if location_name else "Entry Reception"
 
         # Generate current timestamp
         current_timestamp = datetime.now(timezone.utc).isoformat()
@@ -1806,7 +1933,8 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
             processed_detection = await self._process_face(
                 detection, current_frame, location, current_timestamp, config,
                 current_recognized_count, current_unknown_count, 
-                recognized_persons, current_frame_staff_details
+                recognized_persons, current_frame_staff_details,
+                camera_name=camera_name, camera_id=camera_id
             )
             # print("------------------WHOLE FACE RECOG PROCESSING DETECTION----------------------------")
             # print("LATENCY:",(time.time() - st1)*1000,"| Throughput fps:",(1.0 / (time.time() - st1)) if (time.time() - st1) > 0 else None)
@@ -1838,6 +1966,8 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
         current_unknown_count: int = 0,
         recognized_persons: Dict = None,
         current_frame_staff_details: Dict = None,
+        camera_name: str = "",
+        camera_id: str = "",
     ) -> Dict:
 
         # Extract and validate embedding using EmbeddingManager
@@ -2011,6 +2141,8 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
                     detection=detection,
                     current_frame=current_frame,
                     location=location,
+                    camera_name=camera_name,
+                    camera_id=camera_id,
                 )
                 # print("------------------FACE RECOG ENQUEUEING DETECTION FOR ACTIVITY LOGGING----------------------------")
                 # print("LATENCY:",(time.time() - st4)*1000,"| Throughput fps:",(1.0 / (time.time() - st4)) if (time.time() - st4) > 0 else None)
@@ -2273,19 +2405,19 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
 
         # Build current_counts array in expected format
         current_counts = []
-        for cat, count in per_category_count.items():
-            if count > 0 or total_detections > 0:
-                current_counts.append({"category": cat, "count": count})
+        # for cat, count in per_category_count.items():
+        #     if count > 0 or total_detections > 0:
+        #         current_counts.append({"category": cat, "count": count})
 
         # Add face recognition specific current counts
         current_frame = face_summary.get("current_frame", {})
         current_counts.extend(
             [
                 {
-                    "category": "recognized_faces",
+                    "category": "Recognized Faces",
                     "count": current_frame.get("recognized", 0),
                 },
-                {"category": "unknown_faces", "count": current_frame.get("unknown", 0)},
+                {"category": "Unknown Faces", "count": current_frame.get("unknown", 0)},
             ]
         )
 
@@ -2408,7 +2540,7 @@ class FaceRecognitionEmbeddingUseCase(BaseProcessor):
             start_time=high_precision_start_timestamp,
             reset_time=high_precision_reset_timestamp,
         )
-
+        tracking_stat['target_categories'] = ['Recognized Faces', 'Unknown Faces']
         tracking_stats.append(tracking_stat)
         return tracking_stats