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

matrice_analytics/post_processing/__init__.py

@@ -84,6 +84,7 @@ 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.weld_defect_detection import WeldDefectConfig
@@ -128,6 +129,7 @@ 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
 
 #Put all IMAGE based usecases here
 from .usecases.blood_cancer_detection_img import BloodCancerDetectionConfig, BloodCancerDetectionUseCase
@@ -205,7 +207,7 @@ from .usecases import (
 
     SusActivityUseCase,
     NaturalDisasterUseCase,
-
+    FootFallUseCase,
     #Put all IMAGE based usecases here
     BloodCancerDetectionUseCase,
     SkinCancerClassificationUseCase,
@@ -286,6 +288,7 @@ _pcb_defect_detection = PCBDefectUseCase()
 _underground_pipeline_defect = UndergroundPipelineDefectUseCase()
 _suspicious_activity_detection = SusActivityUseCase()
 _natural_disaster = NaturalDisasterUseCase()
+_footfall = FootFallUseCase()
 
 # Face recognition with embeddings
 _face_recognition = FaceRecognitionEmbeddingUseCase()
@@ -370,6 +373,7 @@ 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)
 
 #Put all IMAGE based usecases here
 registry.register_use_case(_blood_cancer_detection.category, _blood_cancer_detection.name, BloodCancerDetectionUseCase)
@@ -574,7 +578,8 @@ __all__ = [
     'UndergroundPipelineDefectConfig',
     'SusActivityConfig',
     'NaturalDisasterConfig',
-    'VehiclePeopleDroneMonitoringConfig'
+    'VehiclePeopleDroneMonitoringConfig',
+    'FootFallConfig',
     #Put all IMAGE based usecase CONFIGS here
     'BloodCancerDetectionConfig',
     'SkinCancerClassificationConfig',
@@ -648,6 +653,7 @@ __all__ = [
     'UndergroundPipelineDefectUseCase',
     'SusActivityUseCase',
     'NaturalDisasterUseCase',
+    'FootFallUseCase',
 
     #Put all IMAGE based usecases here
     'BloodCancerDetectionUseCase',

matrice_analytics/post_processing/config.py

@@ -65,6 +65,7 @@ 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"
 }
 
 APP_NAME_TO_CATEGORY = {
@@ -135,6 +136,7 @@ APP_NAME_TO_CATEGORY = {
     "underground_pipeline_defect" : "general",
     "suspicious_activity_detection": "security",
     "natural_disaster_detection": "environmental",
+    "Foot Fall": "retail"
 }
 
 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,7 @@ class ConfigManager:
             'underground_pipeline_defect' : None,
             'suspicious_activity_detection': None,
             'natural_disaster_detection': None,
+            'footfall': None,
 
             #Put all image based usecases here::
             'blood_cancer_detection_img': None,
@@ -1405,7 +1411,15 @@ 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
+        
     #put all image based usecases here::
     def blood_cancer_detection_config_class(self):
         """Register a configuration class for a use case."""
@@ -2684,6 +2698,22 @@ 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
+            )
+        
         #Add IMAGE based usecases here::
         elif usecase == "blood_cancer_detection_img":
             # Import here to avoid circular import
@@ -3234,6 +3264,13 @@ 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 == "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
 

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):