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

matrice_analytics/post_processing/face_reg/face_recognition_client.py

@@ -7,6 +7,7 @@ in the post-processing pipeline using Matrice Session.
 """
 
 import os
+import re
 import base64
 import logging
 import httpx
@@ -14,6 +15,7 @@ import urllib
 import urllib.request
 from typing import List, Dict, Any, Optional
 from datetime import datetime, timezone
+from pathlib import Path
 
 # Import matrice session
 try:
@@ -29,6 +31,78 @@ class FacialRecognitionClient:
     Simplified Face Recognition Client using Matrice Session.
     All API calls are made through the Matrice session RPC interface.
     """
+    
+    # Pattern for matching action IDs (hex strings of at least 8 characters)
+    ACTION_ID_PATTERN = re.compile(r"^[0-9a-f]{8,}$", re.IGNORECASE)
+
+    @classmethod
+    def _discover_action_id(cls) -> Optional[str]:
+        """Discover action_id from current working directory name (and parents)."""
+        candidates: List[str] = []
+        try:
+            cwd = Path.cwd()
+            candidates.append(cwd.name)
+            for parent in cwd.parents:
+                candidates.append(parent.name)
+        except Exception:
+            pass
+
+        try:
+            usr_src = Path("/usr/src")
+            if usr_src.exists():
+                for child in usr_src.iterdir():
+                    if child.is_dir():
+                        candidates.append(child.name)
+        except Exception:
+            pass
+
+        for candidate in candidates:
+            if candidate and len(candidate) >= 8 and cls.ACTION_ID_PATTERN.match(candidate):
+                return candidate
+        return None
+
+    def _fetch_project_id_from_action(self) -> Optional[str]:
+        """
+        Fetch project ID from action details using discovered action ID.
+        
+        This method discovers the action ID from the working directory name,
+        fetches action details from the API, and extracts the _idProject field.
+        If successful, it also updates the MATRICE_PROJECT_ID environment variable.
+        
+        Returns:
+            The project ID string if found, None otherwise.
+        """
+        action_id = self._discover_action_id()
+        if not action_id:
+            self.logger.warning("[PROJECT_ID] Could not discover action_id from folder name")
+            return None
+        
+        self.logger.info(f"[PROJECT_ID] Discovered action_id from folder: {action_id}")
+        
+        try:
+            url = f"/v1/actions/action/{action_id}/details"
+            self.logger.info(f"[PROJECT_ID] Fetching action details from: {url}")
+            response = self.session.rpc.get(url)
+            
+            if response and response.get("success", False) and response.get("code") == 200:
+                data = response.get("data", {})
+                project_id = data.get("_idProject", "")
+                
+                if project_id:
+                    self.logger.info(f"[PROJECT_ID] Successfully fetched project ID from action details: {project_id}")
+                    # Update environment variable so other components can use it
+                    os.environ["MATRICE_PROJECT_ID"] = project_id
+                    self.logger.info(f"[PROJECT_ID] Updated MATRICE_PROJECT_ID environment variable: {project_id}")
+                    return project_id
+                else:
+                    self.logger.warning(f"[PROJECT_ID] _idProject not found in action details for action_id={action_id}")
+            else:
+                error_msg = response.get('message', 'Unknown error') if response else 'Empty response'
+                self.logger.warning(f"[PROJECT_ID] Failed to fetch action details: {error_msg}")
+        except Exception as e:
+            self.logger.error(f"[PROJECT_ID] Error fetching action details for action_id={action_id}: {e}", exc_info=True)
+        
+        return None
 
     def __init__(self, account_number: str = "", access_key: str = "", secret_key: str = "", 
                  project_id: str = "", server_id: str = "", session=None):
@@ -75,6 +149,23 @@ class FacialRecognitionClient:
             except Exception as e:
                 self.logger.error(f"Failed to initialize Matrice session: {e}", exc_info=True)
                 raise
+        
+        # If project_id is still empty, try to fetch from action details
+        if not self.project_id:
+            self.logger.info("[PROJECT_ID] Project ID is empty, attempting to fetch from action details...")
+            fetched_project_id = self._fetch_project_id_from_action()
+            if fetched_project_id:
+                self.project_id = fetched_project_id
+                self.logger.info(f"[PROJECT_ID] Successfully set project_id from action details: {self.project_id}")
+                # Update session with the new project_id if possible
+                if hasattr(self.session, 'update'):
+                    try:
+                        self.session.update(self.project_id)
+                        self.logger.info(f"[PROJECT_ID] Updated session with project_id: {self.project_id}")
+                    except Exception as e:
+                        self.logger.warning(f"[PROJECT_ID] Failed to update session with project_id: {e}")
+            else:
+                self.logger.warning("[PROJECT_ID] Could not fetch project_id from action details")
 
         # Fetch server connection info if server_id is provided
         if self.server_id:
@@ -93,12 +184,29 @@ class FacialRecognitionClient:
                         self.server_base_url = f"http://{server_host}:{server_port}"
                         self.logger.warning(f"Facial recognition server base URL: {self.server_base_url}")
                     
-                    self.session.update(self.server_info.get('projectID', ''))
-                    self.logger.info(f"Updated Matrice session with project ID: {self.server_info.get('projectID', '')}")
+                    # Update project_id from server_info if available and current project_id is empty
+                    server_project_id = self.server_info.get('projectID', '')
+                    if server_project_id:
+                        if not self.project_id:
+                            self.project_id = server_project_id
+                            self.logger.info(f"[PROJECT_ID] Set project_id from server_info: {self.project_id}")
+                            # Update environment variable
+                            os.environ["MATRICE_PROJECT_ID"] = self.project_id
+                            self.logger.info(f"[PROJECT_ID] Updated MATRICE_PROJECT_ID env var from server_info: {self.project_id}")
+                        self.session.update(server_project_id)
+                        self.logger.info(f"Updated Matrice session with project ID: {server_project_id}")
+                    else:
+                        self.logger.warning("[PROJECT_ID] server_info.projectID is empty")
                 else:
                     self.logger.warning("Failed to fetch facial recognition server connection info")
             except Exception as e:
                 self.logger.error(f"Error fetching facial recognition server connection info: {e}", exc_info=True)
+        
+        # Final check: log the project_id status
+        if self.project_id:
+            self.logger.info(f"[PROJECT_ID] Final project_id: {self.project_id}")
+        else:
+            self.logger.error("[PROJECT_ID] WARNING: project_id is still empty after all initialization attempts!")
     
     def _get_public_ip(self) -> str:
         """Get the public IP address of this machine."""
@@ -286,6 +394,8 @@ class FacialRecognitionClient:
                                   employee_id: Optional[str] = None,
                                   timestamp: str = datetime.now(timezone.utc).isoformat(),
                                   image_data: Optional[str] = None,
+                                  camera_name: Optional[str] = None,
+                                  camera_id: Optional[str] = None,
                                   ) -> Dict[str, Any]:
         """
         Store people activity data with optional image data
@@ -310,6 +420,8 @@ class FacialRecognitionClient:
             "timestamp": timestamp,
             "bbox": bbox,
             "location": location,
+            "camera_name": camera_name,
+            "camera_id": camera_id,
         }
 
         # Add optional fields if provided based on API spec
@@ -322,8 +434,8 @@ class FacialRecognitionClient:
         if image_data:
             activity_request["imageData"] = image_data
         
-        self.logger.info(f"API REQUEST: Storing people activity - type={detection_type}, staff_id={staff_id}, location={location}, has_image={bool(image_data)}")
-        self.logger.debug(f"Activity request payload: bbox={bbox}, employee_id={employee_id}")
+        self.logger.info(f"API REQUEST: Storing people activity - type={detection_type}, staff_id={staff_id}, location={location}, camera_name={camera_name}, camera_id={camera_id}, has_image={bool(image_data)}")
+        self.logger.debug(f"Activity request payload: bbox={bbox}, employee_id={employee_id}, camera_name={camera_name}, camera_id={camera_id}")
         
         try:
             response = await self.session.rpc.async_send_request(

matrice_analytics/post_processing/face_reg/people_activity_logging.py

@@ -4,6 +4,7 @@ import time
 import threading
 import queue
 import base64
+import os
 from typing import Dict, Optional, Set
 import numpy as np
 import cv2
@@ -18,6 +19,15 @@ class PeopleActivityLogging:
         self.face_client = face_client
         self.logger = logging.getLogger(__name__)
 
+        # Log project ID information for observability and debugging
+        face_client_project_id = getattr(self.face_client, "project_id", None) if self.face_client else None
+        env_project_id = os.getenv("MATRICE_PROJECT_ID", "")
+        self.logger.info(
+            "[PROJECT_ID] PeopleActivityLogging initialized "
+            f"with face_client.project_id='{face_client_project_id}', "
+            f"MATRICE_PROJECT_ID env='{env_project_id}'"
+        )
+
         # Use thread-safe queue for cross-thread communication (Python 3.8 compatibility)
         self.activity_queue = queue.Queue()
 
@@ -95,6 +105,8 @@ class PeopleActivityLogging:
         detection: Dict,
         current_frame: Optional[np.ndarray] = None,
         location: str = "",
+        camera_name: str = "",
+        camera_id: str = "",
     ):
         """Enqueue a detection for background processing"""
         try:
@@ -103,6 +115,8 @@ class PeopleActivityLogging:
                 "detection": detection,
                 "current_frame": current_frame,
                 "location": location,
+                "camera_name": camera_name,
+                "camera_id": camera_id,
                 "timestamp": datetime.now(timezone.utc).isoformat(),
                 "employee_id": detection.get("employee_id", None),
                 "staff_id": detection.get("person_id")
@@ -178,7 +192,10 @@ class PeopleActivityLogging:
         location = activity_data["location"]
         staff_id = activity_data["staff_id"]
         timestamp = activity_data["timestamp"]
+        camera_name = activity_data.get("camera_name", "")
+        camera_id = activity_data.get("camera_id", "")
         
+        self.logger.debug(f"Processing activity - location: '{location}', camera_name: '{camera_name}', camera_id: '{camera_id}'")
         try:
             if not self.face_client:
                 self.logger.warning("Face client not available for activity logging")
@@ -211,6 +228,8 @@ class PeopleActivityLogging:
                 employee_id=employee_id,
                 timestamp=timestamp,
                 image_data=image_data,
+                camera_name=camera_name,
+                camera_id=camera_id,
             )
 
             if response and response.get("success", False):

matrice_analytics/post_processing/post_processor.py

@@ -99,6 +99,9 @@ from .usecases import (
     UndergroundPipelineDefectUseCase,
     SusActivityUseCase,
     NaturalDisasterUseCase,
+    FootFallUseCase,
+    VehicleMonitoringParkingLotUseCase,
+    VehicleMonitoringDroneViewUseCase,
     # Put all IMAGE based usecases here
     BloodCancerDetectionUseCase,
     SkinCancerClassificationUseCase,
@@ -569,6 +572,15 @@ class PostProcessor:
         registry.register_use_case(
             "environmental", "natural_disaster_detection", NaturalDisasterUseCase
         )
+        registry.register_use_case(
+            "retail", "footfall", FootFallUseCase
+        )
+        registry.register_use_case(
+            "traffic", "vehicle_monitoring_parking_lot", VehicleMonitoringParkingLotUseCase
+        )
+        registry.register_use_case(
+            "traffic", "vehicle_monitoring_drone_view", VehicleMonitoringDroneViewUseCase
+        )
 
         # Put all IMAGE based usecases here
         registry.register_use_case(

matrice_analytics/post_processing/usecases/__init__.py

@@ -85,6 +85,9 @@ from .pcb_defect_detection import PCBDefectConfig, PCBDefectUseCase
 from .underground_pipeline_defect_detection import UndergroundPipelineDefectConfig,UndergroundPipelineDefectUseCase
 from .suspicious_activity_detection import SusActivityConfig, SusActivityUseCase
 from .natural_disaster import NaturalDisasterConfig, NaturalDisasterUseCase
+from .footfall import FootFallConfig, FootFallUseCase
+from .vehicle_monitoring_parking_lot import VehicleMonitoringParkingLotUseCase, VehicleMonitoringParkingLotConfig
+from .vehicle_monitoring_drone_view import VehicleMonitoringDroneViewUseCase, VehicleMonitoringDroneViewConfig
 
 #Put all IMAGE based usecases here
 from .blood_cancer_detection_img import BloodCancerDetectionConfig, BloodCancerDetectionUseCase
@@ -172,6 +175,9 @@ __all__ = [
     'UndergroundPipelineDefectUseCase',
     'SusActivityUseCase',
     'NaturalDisasterUseCase',
+    'FootFallUseCase',
+    'VehicleMonitoringParkingLotUseCase',
+    'VehicleMonitoringDroneViewUseCase',
 
     #Put all IMAGE based usecases here
     'BloodCancerDetectionUseCase',
@@ -254,6 +260,9 @@ __all__ = [
     'PCBDefectConfig',
     'SusActivityConfig',
     'NaturalDisasterConfig',
+    'FootFallConfig',
+    'VehicleMonitoringParkingLotConfig',
+    'VehicleMonitoringDroneViewConfig',
 
     #Put all IMAGE based usecase CONFIGS here
     'BloodCancerDetectionConfig',

matrice_analytics/post_processing/usecases/advanced_customer_service.py

@@ -74,6 +74,8 @@ class AdvancedCustomerServiceUseCase(BaseProcessor):
         """Initialize advanced customer service use case."""
         super().__init__("advanced_customer_service")
         self.category = "sales"
+        self.CASE_TYPE: Optional[str] = 'advanced_customer_service'
+        self.CASE_VERSION: Optional[str] = '1.3'
 
         # Advanced tracking structures
         self.customer_occupancy = {}
@@ -496,7 +498,7 @@ class AdvancedCustomerServiceUseCase(BaseProcessor):
             # Calculate current_counts (frame-wise counts)
             current_counts = [
                 {"category": "staff", "count": staff_analytics.get("active_staff", 0)},
-                {"category": "customer", "count": queue_analytics.get("active_customers", 0)}
+                {"category": "Active Customers", "count": queue_analytics.get("active_customers", 0)}
             ]
             # Detections: include all detections for this frame
             detection_objs = []
@@ -529,7 +531,8 @@ class AdvancedCustomerServiceUseCase(BaseProcessor):
                 "alerts": alerts,
                 "alert_settings": alert_settings,
                 "reset_settings": reset_settings,
-                "human_text": human_text
+                "human_text": human_text,
+                "target_categories": ['Staff', 'Active Customers']
             }
             # Patch: Build real_time_occupancy with correct service_areas info (not just empty lists)
             real_time_occupancy = analytics_results.get("real_time_occupancy", {}).copy()

matrice_analytics/post_processing/usecases/color_detection.py

@@ -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/fire_detection.py

@@ -107,7 +107,7 @@ class FireSmokeUseCase(BaseProcessor):
 
         self.smoothing_tracker = None  # Required for bbox smoothing
         self._fire_smoke_recent_history = []
-        self.target_categories=['fire']
+        self.target_categories=['fire', 'smoke']  # Lowercase to match filtering logic at line 276
 
         self._ascending_alert_list: List[str] = []
         self.current_incident_end_timestamp: str = "N/A"
@@ -538,9 +538,21 @@ class FireSmokeUseCase(BaseProcessor):
             count_thresholds = {}
             if config.alert_config and hasattr(config.alert_config, "count_thresholds"):
                 count_thresholds = config.alert_config.count_thresholds or {}
+            
+            # CRITICAL FIX: Ensure we have at least one category to process
+            # If count_thresholds is empty, use detected categories from per_category_count
+            # This ensures incidents are always generated when detections exist
+            per_category_count = summary.get("per_category_count", {})
+            if not count_thresholds and per_category_count:
+                # Create thresholds for all detected categories with threshold=0 (always trigger)
+                count_thresholds = {cat: 0 for cat in per_category_count.keys()}
+                self.logger.debug(f"[INCIDENT] count_thresholds was empty, using detected categories: {count_thresholds}")
+            
+            # Flag to track if we generated any incident
+            incident_generated = False
 
             for category, threshold in count_thresholds.items():
-                if category in summary.get("per_category_count", {}):
+                if category in per_category_count:
                     
                     #count = summary.get("per_category_count", {})[category]
                     start_timestamp = self._get_start_timestamp_str(stream_info)
@@ -643,6 +655,55 @@ class FireSmokeUseCase(BaseProcessor):
                     event['duration'] = self.get_duration_seconds(start_timestamp, self.current_incident_end_timestamp)
                     event['incident_quant'] = intensity_pct
                     incidents.append(event)
+                    incident_generated = True
+            
+            # CRITICAL FALLBACK: If no incident was generated despite having detections,
+            # generate a basic incident to ensure the incident manager receives data
+            if not incident_generated and total > 0:
+                self.logger.warning(f"[INCIDENT] No incident generated despite {total} detections. Generating fallback incident.")
+                # Calculate area and intensity for fallback
+                for det in detections:
+                    bbox = det.get("bounding_box") or det.get("bbox")
+                    if bbox:
+                        xmin, ymin = bbox.get("xmin"), bbox.get("ymin")
+                        xmax, ymax = bbox.get("xmax"), bbox.get("ymax")
+                        if None not in (xmin, ymin, xmax, ymax):
+                            width, height = xmax - xmin, ymax - ymin
+                            if width > 0 and height > 0:
+                                total_area += width * height
+                
+                threshold_area = config.threshold_area or 250200.0
+                intensity_pct = min(100.0, (total_area / threshold_area) * 100)
+                
+                # Determine severity level
+                if intensity_pct >= 30:
+                    level = "critical"
+                elif intensity_pct >= 13:
+                    level = "significant"
+                elif intensity_pct >= 3:
+                    level = "medium"
+                else:
+                    level = "low"
+                self._ascending_alert_list.append(level)
+                
+                start_timestamp = self._get_start_timestamp_str(stream_info)
+                human_text = f"INCIDENTS DETECTED @ {current_timestamp}:\n\tSeverity Level: {(self.CASE_TYPE, level)}"
+                
+                event = self.create_incident(
+                    incident_id='incident_' + self.CASE_TYPE + '_fallback',
+                    incident_type=self.CASE_TYPE,
+                    severity_level=level,
+                    human_text=human_text,
+                    camera_info=camera_info,
+                    alerts=alerts,
+                    alert_settings=[],
+                    start_time=start_timestamp,
+                    end_time='Incident still active',
+                    level_settings={"low": 3, "medium": 5, "significant": 15, "critical": 30}
+                )
+                event['incident_quant'] = intensity_pct
+                incidents.append(event)
+                self.logger.info(f"[INCIDENT] Generated fallback incident with level={level}, intensity={intensity_pct:.2f}%")
 
         else:
             #self._ascending_alert_list.append(level)
@@ -689,20 +750,39 @@ class FireSmokeUseCase(BaseProcessor):
 
     
         # Build total_counts array in expected format
+        # ALWAYS populate with all target categories to avoid empty arrays downstream
         total_counts = []
         if total > 0:
-                total_counts.append({
-                    "category": 'Fire/Smoke',  #TODO: Discuss and fix what to do with this
-                    "count": 1
-                })
+            total_counts.append({
+                "category": 'Fire/Smoke',
+                "count": 1
+            })
+        else:
+            # When no detections, send count=0 for each category to avoid empty array
+            total_counts.append({
+                "category": 'Fire',
+                "count": 0
+            })
+            total_counts.append({
+                "category": 'Smoke',
+                "count": 0
+            })
 
-        # Build current_counts array in expected format  
+        # Build current_counts array in expected format
+        # ALWAYS populate with all target categories to avoid empty arrays downstream
         current_counts = []
-        if total > 0:  # Include even if 0 when there are detections
-                current_counts.append({
-                    "category": 'Fire/Smoke',  #TODO: Discuss and fix what to do with this
-                    "count": 1
-                })
+        
+        # Add Fire entry (count=1 if detected, count=0 if not)
+        current_counts.append({
+            "category": 'Fire',
+            "count": 1 if total_fire > 0 else 0
+        })
+        
+        # Add Smoke entry (count=1 if detected, count=0 if not)
+        current_counts.append({
+            "category": 'Smoke',
+            "count": 1 if total_smoke > 0 else 0
+        })
 
         human_lines = [f"CURRENT FRAME @ {current_timestamp}:"]
         if total_fire > 0:
@@ -773,8 +853,8 @@ class FireSmokeUseCase(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)
 
         if len(self.id_hit_list)==1: