matrice-analytics 0.1.31__py3-none-any.whl → 0.1.33__py3-none-any.whl

matrice_analytics/post_processing/face_reg/people_activity_logging.py

@@ -3,6 +3,7 @@ import logging
 import time
 import threading
 import queue
+import base64
 from typing import Dict, Optional, Set
 import numpy as np
 import cv2
@@ -169,7 +170,7 @@ class PeopleActivityLogging:
         return True
 
     async def _process_activity(self, activity_data: Dict):
-        """Process activity data - handle all face detections and uploads"""
+        """Process activity data - handle all face detections with embedded image data"""
         detection_type = activity_data["detection_type"]
         current_frame = activity_data["current_frame"]
         bbox = activity_data["bbox"]
@@ -188,27 +189,57 @@ class PeopleActivityLogging:
                 self.logger.debug(f"Skipping activity log for employee_id={employee_id} (within cooldown period)")
                 return None
 
-            # Store activity data
+            # Encode frame as base64 JPEG
+            image_data = None
+            if current_frame is not None:
+                try:
+                    self.logger.debug(f"Encoding frame as base64 JPEG - employee_id={employee_id}")
+                    _, buffer = cv2.imencode(".jpg", current_frame)
+                    frame_bytes = buffer.tobytes()
+                    image_data = base64.b64encode(frame_bytes).decode('utf-8')
+                    self.logger.debug(f"Encoded image data - employee_id={employee_id}, size={len(frame_bytes)} bytes")
+                except Exception as e:
+                    self.logger.error(f"Error encoding frame for employee_id={employee_id}: {e}", exc_info=True)
+
+            # Store activity data with embedded image
             self.logger.info(f"Processing activity log - type={detection_type}, employee_id={employee_id}, staff_id={staff_id}, location={location}")
-            upload_url = await self.face_client.store_people_activity(
+            response = await self.face_client.store_people_activity(
                 staff_id=staff_id,
                 detection_type=detection_type,
                 bbox=bbox,
                 location=location,
                 employee_id=employee_id,
                 timestamp=timestamp,
+                image_data=image_data,
             )
 
-            if upload_url:
-                self.logger.info(f"Activity log stored successfully, upload URL received for employee_id={employee_id}")
-                await self._upload_frame(current_frame, upload_url, employee_id)
+            if response and response.get("success", False):
+                self.logger.info(f"Activity log stored successfully for employee_id={employee_id}")
             else:
-                self.logger.warning(f"Failed to store activity log for employee_id={employee_id} - no upload URL returned")
+                error_msg = response.get("error", "Unknown error") if response else "No response"
+                self.logger.warning(f"Failed to store activity log for employee_id={employee_id} - {error_msg}")
 
-            return upload_url
+            return response
         except Exception as e:
             self.logger.error(f"Error processing activity log for employee_id={employee_id}: {e}", exc_info=True)
-
+    
+    # async def _upload_frame_to_url(self, current_frame: np.ndarray, upload_url: str, employee_id: str):
+    #     try:
+    #         self.logger.debug(f"Encoding frame for upload - employee_id={employee_id}")
+    #         _, buffer = cv2.imencode(".jpg", current_frame)
+    #         frame_bytes = buffer.tobytes()
+            
+    #         self.logger.info(f"Uploading frame to storage - employee_id={employee_id}, size={len(frame_bytes)} bytes")
+    #         upload_success = await self.face_client.upload_image_to_url(
+    #             frame_bytes, upload_url
+    #         )
+
+    #         if upload_success:
+    #             self.logger.info(f"Frame uploaded successfully for employee_id={employee_id}")
+    #         else:
+    #             self.logger.warning(f"Failed to upload frame for employee_id={employee_id}")
+    #     except Exception as e:
+    #         self.logger.error(f"Error uploading frame for employee_id={employee_id}: {e}", exc_info=True)
 
     async def _upload_frame(self, current_frame: np.ndarray, upload_url: str, employee_id: str):
         try:

matrice_analytics/post_processing/post_processor.py

@@ -320,6 +320,7 @@ class PostProcessor:
                     f"Removing facial_recognition_server_id from {usecase} config"
                 )
                 config_params.pop("facial_recognition_server_id", None)
+                config_params.pop("deployment_id", None)
         
         if usecase not in license_plate_monitoring_usecases:
             if "lpr_server_id" in config_params:
@@ -642,7 +643,7 @@ class PostProcessor:
         config_str = json.dumps(cache_data, sort_keys=True, default=str)
         return hashlib.md5(config_str.encode()).hexdigest()[:16]  # Shorter hash for readability
 
-    def _get_use_case_instance(
+    async def _get_use_case_instance(
         self, config: BaseConfig, stream_key: Optional[str] = None
     ):
         """
@@ -669,8 +670,10 @@ class PostProcessor:
             raise ValueError(f"Use case '{config.category}/{config.usecase}' not found")
 
         
-        if isinstance(use_case_class, FaceRecognitionEmbeddingUseCase):
+        if use_case_class == FaceRecognitionEmbeddingUseCase:
             use_case = use_case_class(config=config)
+            # Await async initialization for face recognition use case
+            await use_case.initialize(config)
         else:
             use_case = use_case_class()
         logger.info(f"Created use case instance for: {config.category}/{config.usecase}")
@@ -759,16 +762,20 @@ class PostProcessor:
         
         try:
             if config:
-                parsed_config = self._parse_config(config)
-            else:
-                parsed_config = self.post_processing_config
+                try:
+                    config = self._parse_config(config)
+                except Exception as e:
+                    logger.error(f"Failed to parse config: {e}", exc_info=True)
+                    raise ValueError(f"Failed to parse config: {e}")
+
+            parsed_config = config or self.post_processing_config
                 
             if not parsed_config:
                 raise ValueError("No valid configuration found")
 
 
-            # Get cached use case instance
-            use_case = self._get_use_case_instance(parsed_config, stream_key)
+            # Get cached use case instance (await since it's async now)
+            use_case = await self._get_use_case_instance(parsed_config, stream_key)
 
             # Create context if not provided
             if context is None:

matrice_analytics/post_processing/usecases/color_detection.py

@@ -86,7 +86,7 @@ class ColorDetectionConfig(BaseConfig):
     smoothing_window_size: int = 20
     smoothing_cooldown_frames: int = 5
     smoothing_confidence_range_factor: float = 0.5
-    detector = True
+    enable_detector: bool = True
 
     #JBK_720_GATE POLYGON = [[86, 328], [844, 317], [1277, 520], [1273, 707], [125, 713]]
     zone_config: Optional[Dict[str, List[List[float]]]] = None #field(
@@ -116,25 +116,24 @@ class ColorDetectionConfig(BaseConfig):
             errors.append("smoothing_confidence_range_factor must be positive")
         return errors
     
-    def __post_init__(self):
-        # Lazy initialization: the ClipProcessor will be created once by the use case
-        # to avoid repeated model downloads and to ensure GPU session reuse.
-        # log_file = open("pip_jetson_bt.log", "w")
-        # cmd = ["pip", "install", "--force-reinstall", "huggingface_hub", "regex", "safetensors"]
-        # subprocess.Popen(
-        #         cmd,
-        #         stdout=log_file,
-        #         stderr=subprocess.STDOUT,
-        #         preexec_fn=os.setpgrp   
-        #     )
-        print("Came to post_init and libraries installed!!!")
-        if self.detector:
-            self.detector = ClipProcessor()
-            print("ClipProcessor Loaded Successfully!!") 
-        else:
-            print("Clip color detector disabled by config")
-            self.detector = None
-    
+    # def __post_init__(self):
+    #     # Lazy initialization: the ClipProcessor will be created once by the use case
+    #     # to avoid repeated model downloads and to ensure GPU session reuse.
+    #     # log_file = open("pip_jetson_bt.log", "w")
+    #     # cmd = ["pip", "install", "--force-reinstall", "huggingface_hub", "regex", "safetensors"]
+    #     # subprocess.Popen(
+    #     #         cmd,
+    #     #         stdout=log_file,
+    #     #         stderr=subprocess.STDOUT,
+    #     #         preexec_fn=os.setpgrp   
+    #     #     )
+    #     print("Came to post_init and libraries installed!!!")
+    #     if self.detector:
+    #         self.detector = ClipProcessor()
+    #         print("ClipProcessor Loaded Successfully!!") 
+    #     else:
+    #         print("Clip color detector disabled by config")
+    #         self.detector = None
 
 
 class ColorDetectionUseCase(BaseProcessor):
@@ -182,7 +181,7 @@ class ColorDetectionUseCase(BaseProcessor):
         self._zone_current_counts = {}  # zone_name -> current count in zone
         self._zone_total_counts = {}  # zone_name -> total count that have been in zone
         self.logger.info("Initialized ColorDetectionUseCase with tracking")
-        #self.detector = None
+        self.detector = None  # Will be initialized on first use
         self.all_color_data = {}
         self.all_color_counts = {}
         self.total_category_count = {}
@@ -294,30 +293,29 @@ class ColorDetectionUseCase(BaseProcessor):
             if config.zone_config:
                 color_processed_data = self._is_in_zone_robust(color_processed_data,config.zone_config)
             print(color_processed_data)
+            
+            # Initialize detector lazily on first use if enabled
             try:
                 print("About to call process_color_in_frame...")
-
-                if config.detector is None:
-                    print("ERROR: Detector is None after initialization attempt!")
+                
+                if config.enable_detector and self.detector is None:
+                    print("Initializing ClipProcessor for color detection...")
+                    try:
+                        self.detector = ClipProcessor()
+                        print("ClipProcessor loaded successfully!")
+                        logger.info("ClipProcessor loaded successfully!")
+                    except Exception as init_error:
+                        print(f"Failed to initialize ClipProcessor: {init_error}")
+                        logger.error(f"Failed to initialize ClipProcessor: {init_error}")
+                        self.detector = None
+
+                if self.detector is None:
+                    print("Detector is disabled or failed to initialize, skipping color detection")
+                    logger.warning("Detector is disabled or failed to initialize, skipping color detection")
                     curr_frame_color = {}
-
-                # else:
-                  # if color_processed_data:
-                  #   t_id = color_processed_data[0].get('track_id')
-                  #   if t_id is not None and t_id not in self.all_color_data:
-                  #       # curr_frame_color = {}
-                  #       curr_frame_color = config.detector.process_color_in_frame(color_processed_data,input_bytes,config.zone_config,stream_info)
-                  #       res_dict[curr_frame_color[t_id]['color']] = curr_frame_color[t_id]['confidence']
-                  #   else:
-                  #       curr_frame_color = {}
-                  #   print("process_color_in_frame completed successfully")
-                  # else:
-                  #   curr_frame_color = {}
-
-                #------------------------ORiginal Code to run on all frames-----------------------
                 else:
                     print(len(color_processed_data))
-                    curr_frame_color = config.detector.process_color_in_frame(
+                    curr_frame_color = self.detector.process_color_in_frame(
                         color_processed_data,
                         input_bytes,
                         config.zone_config,

matrice_analytics/post_processing/usecases/license_plate_monitoring.py

@@ -29,6 +29,7 @@ import logging
 import asyncio
 import urllib
 import urllib.request
+import base64
 # Get the major and minor version numbers
 major_version = sys.version_info.major
 minor_version = sys.version_info.minor
@@ -36,24 +37,22 @@ print(f"Python version: {major_version}.{minor_version}")
 os.environ["ORT_LOG_SEVERITY_LEVEL"] = "3"
 
 
-_ENABLE_OCR_BOOTSTRAP = os.getenv("MATRICE_ENABLE_OCR_BOOTSTRAP", "0")
-if _ENABLE_OCR_BOOTSTRAP == "1":
-    try:
-        from ..ocr.fast_plate_ocr_py38 import LicensePlateRecognizer 
-    except:  
-        class LicensePlateRecognizer: 
-            """Stub fallback when fast_plate_ocr is not installed."""
-            def __init__(self, *args, **kwargs):
-                print("fast_plate_ocr from the local library py_inferenceis required for LicensePlateMonitorUseCase as  platform is determined as python3.8 Jetson")
-else:
+# Try to import LicensePlateRecognizer from local repo first, then installed package
+_OCR_IMPORT_SOURCE = None
+try:
+    from ..ocr.fast_plate_ocr_py38 import LicensePlateRecognizer
+    _OCR_IMPORT_SOURCE = "local_repo"
+except ImportError:
     try:
         from fast_plate_ocr import LicensePlateRecognizer  # type: ignore
-    except:  # pragma: no cover – optional dependency may be absent
-        logging.error("fast_plate_ocr is required for LicensePlateMonitorUseCase but is not installed.")
+        _OCR_IMPORT_SOURCE = "installed_package"
+    except ImportError:
+        # Use stub class if neither import works
+        _OCR_IMPORT_SOURCE = "stub"
         class LicensePlateRecognizer:  # type: ignore
-            """Stub fallback when fast_plate_ocr is not installed."""
+            """Stub fallback when fast_plate_ocr is not available."""
             def __init__(self, *args, **kwargs):
-                print("fast_plate_ocr is required for LicensePlateMonitorUseCase but is not installed.")
+                pass  # Silent stub - error will be logged once during initialization
 
 # Internal utilities that are still required
 from ..ocr.preprocessing import ImagePreprocessor
@@ -124,23 +123,29 @@ class LicensePlateMonitorLogger:
 
     def initialize_session(self, config: LicensePlateMonitorConfig) -> None:
         """Initialize session and fetch server connection info if lpr_server_id is provided."""
+        self.logger.info("Initializing LicensePlateMonitorLogger session...")
+        
         # Use existing session if provided, otherwise create new one
         if self.session:
+            self.logger.info("Session already initialized, skipping initialization")
             return
         if config.session:
             self.session = config.session
+            self.logger.info("Using provided session from config")
         if not self.session:
             # Initialize Matrice session
             if not HAS_MATRICE_SESSION:
+                self.logger.error("Matrice session module not available")
                 raise ImportError("Matrice session is required for License Plate Monitoring")
             try:
+                self.logger.info("Creating new Matrice session...")
                 self.session = Session(
                     account_number=os.getenv("MATRICE_ACCOUNT_NUMBER", ""),
                     access_key=os.getenv("MATRICE_ACCESS_KEY_ID", ""),
                     secret_key=os.getenv("MATRICE_SECRET_ACCESS_KEY", ""),
                     project_id=os.getenv("MATRICE_PROJECT_ID", ""),
                 )
-                self.logger.info("Initialized new Matrice session for License Plate Monitoring")
+                self.logger.info("Successfully initialized new Matrice session for License Plate Monitoring")
             except Exception as e:
                 self.logger.error(f"Failed to initialize Matrice session: {e}", exc_info=True)
                 raise
@@ -148,6 +153,7 @@ class LicensePlateMonitorLogger:
         # Fetch server connection info if lpr_server_id is provided
         if config.lpr_server_id:
             self.lpr_server_id = config.lpr_server_id
+            self.logger.info(f"Fetching LPR server connection info for server ID: {self.lpr_server_id}")
             try:
                 self.server_info = self.get_server_connection_info()
                 if self.server_info:
@@ -158,23 +164,26 @@ class LicensePlateMonitorLogger:
                     
                     if server_host == self.public_ip:
                         self.server_base_url = f"http://localhost:{server_port}"
-                        self.logger.warning(f"Server host matches public IP, using localhost: {self.server_base_url}")
+                        self.logger.info(f"Server host matches public IP ({self.public_ip}), using localhost: {self.server_base_url}")
                     else:
                         self.server_base_url = f"https://{server_host}:{server_port}"
-                        self.logger.warning(f"LPR server base URL: {self.server_base_url}")
+                        self.logger.info(f"LPR server base URL configured: {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', '')}")
                 else:
-                    self.logger.warning("Failed to fetch LPR server connection info")
+                    self.logger.warning("Failed to fetch LPR server connection info - server_info is None")
             except Exception as e:
                 self.logger.error(f"Error fetching LPR server connection info: {e}", exc_info=True)
+        else:
+            self.logger.info("No lpr_server_id provided in config, skipping server connection info fetch")
     
     def _get_public_ip(self) -> str:
         """Get the public IP address of this machine."""
+        self.logger.info("Fetching public IP address...")
         try:
             public_ip = urllib.request.urlopen("https://v4.ident.me", timeout=120).read().decode("utf8").strip()
-            self.logger.warning(f"Successfully fetched external IP: {public_ip}")
+            self.logger.info(f"Successfully fetched external IP: {public_ip}")
             return public_ip
         except Exception as e:
             self.logger.error(f"Error fetching external IP: {e}", exc_info=True)
@@ -183,10 +192,15 @@ class LicensePlateMonitorLogger:
     def get_server_connection_info(self) -> Optional[Dict[str, Any]]:
         """Fetch server connection info from RPC."""
         if not self.lpr_server_id:
+            self.logger.warning("No lpr_server_id set, cannot fetch server connection info")
             return None
         
         try:
-            response = self.session.rpc.get(f"/v1/actions/lpr_servers/{self.lpr_server_id}")
+            endpoint = f"/v1/actions/lpr_servers/{self.lpr_server_id}"
+            self.logger.info(f"Sending GET request to: {endpoint}")
+            response = self.session.rpc.get(endpoint)
+            self.logger.info(f"Received response: success={response.get('success')}, code={response.get('code')}, message={response.get('message')}")
+            
             if response.get("success", False) and response.get("code") == 200:
                 # Response format:
                 # {'success': True,
@@ -202,7 +216,9 @@ class LicensePlateMonitorLogger:
                 # 'projectID': '68ca6372ab79ba13ef699ba6',
                 # 'region': 'United States',
                 # 'isShared': False}}
-                return response.get("data", {})
+                data = response.get("data", {})
+                self.logger.info(f"Server connection info retrieved: name={data.get('name')}, host={data.get('host')}, port={data.get('port')}, status={data.get('status')}")
+                return data
             else:
                 self.logger.warning(f"Failed to fetch server info: {response.get('message', 'Unknown error')}")
                 return None
@@ -214,20 +230,78 @@ class LicensePlateMonitorLogger:
         """Check if enough time has passed since last log for this plate."""
         current_time = time.time()
         last_log_time = self.plate_log_timestamps.get(plate_text, 0)
+        time_since_last_log = current_time - last_log_time
         
-        if current_time - last_log_time >= cooldown:
+        if time_since_last_log >= cooldown:
+            self.logger.debug(f"Plate {plate_text} ready to log (last logged {time_since_last_log:.1f}s ago, cooldown={cooldown}s)")
             return True
-        return False
+        else:
+            self.logger.debug(f"Plate {plate_text} in cooldown period ({time_since_last_log:.1f}s elapsed, {cooldown - time_since_last_log:.1f}s remaining)")
+            return False
     
     def update_log_timestamp(self, plate_text: str) -> None:
         """Update the last log timestamp for a plate."""
         self.plate_log_timestamps[plate_text] = time.time()
+        self.logger.debug(f"Updated log timestamp for plate: {plate_text}")
+    
+    def _format_timestamp_rfc3339(self, timestamp: str) -> str:
+        """Convert timestamp to RFC3339 format (2006-01-02T15:04:05Z).
+        
+        Handles various input formats:
+        - "YYYY-MM-DD-HH:MM:SS.ffffff UTC"
+        - "YYYY:MM:DD HH:MM:SS"
+        - Unix timestamp (float/int)
+        """
+        try:
+            # If already in RFC3339 format, return as is
+            if 'T' in timestamp and timestamp.endswith('Z'):
+                return timestamp
+            
+            # Try to parse common formats
+            dt = None
+            
+            # Format: "2025-08-19-04:22:47.187574 UTC"
+            if '-' in timestamp and 'UTC' in timestamp:
+                timestamp_clean = timestamp.replace(' UTC', '')
+                dt = datetime.strptime(timestamp_clean, '%Y-%m-%d-%H:%M:%S.%f')
+            # Format: "2025:10:23 14:30:45"
+            elif ':' in timestamp and ' ' in timestamp:
+                dt = datetime.strptime(timestamp, '%Y:%m:%d %H:%M:%S')
+            # Format: numeric timestamp
+            elif timestamp.replace('.', '').isdigit():
+                dt = datetime.fromtimestamp(float(timestamp), tz=timezone.utc)
+            
+            if dt is None:
+                # Fallback to current time
+                dt = datetime.now(timezone.utc)
+            else:
+                # Ensure timezone is UTC
+                if dt.tzinfo is None:
+                    dt = dt.replace(tzinfo=timezone.utc)
+            
+            # Format to RFC3339: 2006-01-02T15:04:05Z
+            return dt.strftime('%Y-%m-%dT%H:%M:%SZ')
+            
+        except Exception as e:
+            self.logger.warning(f"Failed to parse timestamp '{timestamp}': {e}. Using current time.")
+            return datetime.now(timezone.utc).strftime('%Y-%m-%dT%H:%M:%SZ')
 
-    async def log_plate(self, plate_text: str, timestamp: str, stream_info: Dict[str, Any], cooldown: float = 30.0) -> bool:
-        """Log plate to RPC server with cooldown period."""
+    async def log_plate(self, plate_text: str, timestamp: str, stream_info: Dict[str, Any], 
+                       image_data: Optional[str] = None, cooldown: float = 30.0) -> bool:
+        """Log plate to RPC server with cooldown period.
+        
+        Args:
+            plate_text: The license plate text
+            timestamp: Capture timestamp
+            stream_info: Stream information dict
+            image_data: Base64-encoded JPEG image of the license plate crop
+            cooldown: Cooldown period in seconds
+        """
+        self.logger.info(f"Attempting to log plate: {plate_text} at {timestamp}")
+        
         # Check cooldown
         if not self.should_log_plate(plate_text, cooldown):
-            self.logger.debug(f"Plate {plate_text} skipped due to cooldown period")
+            self.logger.info(f"Plate {plate_text} NOT SENT - skipped due to cooldown period")
             return False
         
         try:
@@ -236,23 +310,37 @@ class LicensePlateMonitorLogger:
             location = camera_info.get("location", "")
             frame_id = stream_info.get("frame_id", "")
             
+            # Get project ID from server_info
+            project_id = self.server_info.get('projectID', '') if self.server_info else ''
+            
+            # Format timestamp to RFC3339 format (2006-01-02T15:04:05Z)
+            rfc3339_timestamp = self._format_timestamp_rfc3339(timestamp)
+            
             payload = {
                 'licensePlate': plate_text,
                 'frameId': frame_id,
                 'location': location,
                 'camera': camera_name,
-                'captureTimestamp': timestamp
+                'captureTimestamp': rfc3339_timestamp,
+                'projectId': project_id,
+                'imageData': image_data if image_data else ""
             }
             
-            await self.session.rpc.post_async('/v1/lpr-server/detections', payload=payload, base_url=self.server_base_url)
+            # Add projectId as query parameter
+            endpoint = f'/v1/lpr-server/detections?projectId={project_id}'
+            self.logger.info(f"Sending POST request to {self.server_base_url}{endpoint} with plate: {plate_text}, imageData length: {len(image_data) if image_data else 0}")
+            
+            response = await self.session.rpc.post_async(endpoint, payload=payload, base_url=self.server_base_url)
+            
+            self.logger.info(f"API Response received for plate {plate_text}: {response}")
             
             # Update timestamp after successful log
             self.update_log_timestamp(plate_text)
-            self.logger.info(f"Successfully logged plate: {plate_text} at {timestamp}")
+            self.logger.info(f"Plate {plate_text} SUCCESSFULLY SENT and logged at {rfc3339_timestamp}")
             return True
             
         except Exception as e:
-            self.logger.error(f"Failed to log plate {plate_text}: {e}", exc_info=True)
+            self.logger.error(f"Plate {plate_text} NOT SENT - Failed to log: {e}", exc_info=True)
             return False
         
 class LicensePlateMonitorUseCase(BaseProcessor):
@@ -296,11 +384,19 @@ class LicensePlateMonitorUseCase(BaseProcessor):
         self.image_preprocessor = ImagePreprocessor()
         # Fast OCR model (shared across instances)
         if LicensePlateMonitorUseCase._ocr_model is None:
-            try:
+            if _OCR_IMPORT_SOURCE == "stub":
+                # Using stub - log warning once
+                self.logger.error("OCR module not available. LicensePlateRecognizer will not function. Install: pip install fast-plate-ocr[onnx]")
                 LicensePlateMonitorUseCase._ocr_model = LicensePlateRecognizer('cct-s-v1-global-model')
-                self.logger.info("LicensePlateRecognizer loaded successfully")
-            except Exception as e:
-                self.logger.warning(f"Failed to initialise LicensePlateRecognizer: {e}")
+            else:
+                # Try to load real OCR model
+                try:
+                    LicensePlateMonitorUseCase._ocr_model = LicensePlateRecognizer('cct-s-v1-global-model')
+                    source_msg = "from local repo" if _OCR_IMPORT_SOURCE == "local_repo" else "from installed package"
+                    self.logger.info(f"LicensePlateRecognizer loaded successfully {source_msg}")
+                except Exception as e:
+                    self.logger.error(f"Failed to initialize LicensePlateRecognizer: {e}", exc_info=True)
+                    LicensePlateMonitorUseCase._ocr_model = None
         self.ocr_model = LicensePlateMonitorUseCase._ocr_model
         # OCR text history for stability checks (text → consecutive frame count)
         self._text_history: Dict[str, int] = {}
@@ -365,7 +461,7 @@ class LicensePlateMonitorUseCase(BaseProcessor):
             self._logging_enabled = False
     
     def _log_detected_plates(self, detections: List[Dict[str, Any]], config: LicensePlateMonitorConfig, 
-                            stream_info: Optional[Dict[str, Any]]) -> None:
+                            stream_info: Optional[Dict[str, Any]], image_bytes: Optional[bytes] = None) -> None:
         """Log all detected plates to RPC server with cooldown."""
         if not self._logging_enabled or not self.plate_logger or not stream_info:
             return
@@ -373,6 +469,24 @@ class LicensePlateMonitorUseCase(BaseProcessor):
         # Get current timestamp
         current_timestamp = self._get_current_timestamp_str(stream_info, precision=True)
         
+        # Encode the full frame image as base64 JPEG
+        image_data = ""
+        if image_bytes:
+            try:
+                # Decode image bytes
+                image_array = np.frombuffer(image_bytes, np.uint8)
+                image = cv2.imdecode(image_array, cv2.IMREAD_COLOR)
+                
+                if image is not None:
+                    # Encode as JPEG with 85% quality
+                    success, jpeg_buffer = cv2.imencode('.jpg', image, [cv2.IMWRITE_JPEG_QUALITY, 99])
+                    if success:
+                        # Convert to base64
+                        image_data = base64.b64encode(jpeg_buffer.tobytes()).decode('utf-8')
+                        self.logger.debug(f"Encoded frame image as base64, length: {len(image_data)}")
+            except Exception as e:
+                self.logger.error(f"Failed to encode frame image: {e}")
+        
         # Collect all unique plates from current detections
         plates_to_log = set()
         for det in detections:
@@ -394,6 +508,7 @@ class LicensePlateMonitorUseCase(BaseProcessor):
                             plate_text=plate_text,
                             timestamp=current_timestamp,
                             stream_info=stream_info,
+                            image_data=image_data,
                             cooldown=config.plate_log_cooldown
                         )
                         tasks.append(task)
@@ -419,11 +534,6 @@ class LicensePlateMonitorUseCase(BaseProcessor):
             if not input_bytes:
                 return self.create_error_result("input_bytes (video/image) is required for license plate monitoring",
                                                usecase=self.name, category=self.category, context=context)
-                                               
-            print("--------------------------------------")
-            print("config.alert_config",config.alert_config)
-            print(config)
-            print("--------------------------------------")
             
             # Initialize plate logger if lpr_server_id is provided (optional flow)
             if config.lpr_server_id and self._logging_enabled:
@@ -526,7 +636,7 @@ class LicensePlateMonitorUseCase(BaseProcessor):
             self._update_plate_texts(processed_data)
             
             # Step 9.5: Log detected plates to RPC (optional, only if lpr_server_id is provided)
-            self._log_detected_plates(processed_data, config, stream_info)
+            self._log_detected_plates(processed_data, config, stream_info, input_bytes)
             
             # Step 10: Update frame counter
             self._total_frame_counter += 1
@@ -704,15 +814,17 @@ class LicensePlateMonitorUseCase(BaseProcessor):
 
     def _run_ocr(self, crop: np.ndarray) -> str:
         """Run OCR on a cropped plate image and return cleaned text or empty string."""
-        # print("---------OCR CROP22",crop)
-        # print("---------OCR CROP SIZE22",crop.size)
-
         if crop is None or crop.size == 0 or self.ocr_model is None:
             return ""
+        
+        # Check if we have a valid OCR model (not the stub) - silently return empty if stub
+        if not hasattr(self.ocr_model, 'run'):
+            return ""
+            
         try:
-            # fast_plate_ocr expects RGB
-            #rgb_crop = cv2.cvtColor(crop, cv2.COLOR_BGR2RGB)
+            # fast_plate_ocr LicensePlateRecognizer has a run() method
             res = self.ocr_model.run(crop)
+            
             if isinstance(res, list):
                 res = res[0] if res else ""
             cleaned_text = self._clean_text(str(res))
@@ -723,12 +835,14 @@ class LicensePlateMonitorUseCase(BaseProcessor):
                     response = all(ch.isalpha() for ch in cleaned_text)
                 elif self._ocr_mode == "alphanumeric":
                     response = True
+                else:
+                    response = False
                 
                 if response:
                     return cleaned_text
-            else:
-                return ""
+            return ""
         except Exception as exc:
+            # Only log at debug level to avoid spam
             self.logger.warning(f"OCR failed: {exc}")
             return ""
 

{matrice_analytics-0.1.31.dist-info → matrice_analytics-0.1.33.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: matrice_analytics
-Version: 0.1.31
+Version: 0.1.33
 Summary: Common server utilities for Matrice.ai services
 Author-email: "Matrice.ai" <dipendra@matrice.ai>
 License-Expression: MIT