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

matrice_analytics/post_processing/usecases/license_plate_monitoring.py

@@ -24,17 +24,36 @@ import numpy as np
 #import torch
 import re
 from collections import Counter, defaultdict
-#from turbojpeg import TurboJPEG, TJPF_RGB
+import sys
+import logging
+import asyncio
+import urllib
+import urllib.request
+# Get the major and minor version numbers
+major_version = sys.version_info.major
+minor_version = sys.version_info.minor
+print(f"Python version: {major_version}.{minor_version}")
 os.environ["ORT_LOG_SEVERITY_LEVEL"] = "3"
-# Fast license-plate OCR (replaces EasyOCR)
-# Attempt to import fast_plate_ocr; fall back to a stub if unavailable
-try:
-    from fast_plate_ocr import LicensePlateRecognizer  # type: ignore
-except:  # pragma: no cover – optional dependency may be absent
-    class LicensePlateRecognizer:  # type: ignore
-        """Stub fallback when fast_plate_ocr is not installed."""
-        def __init__(self, *args, **kwargs):
-            print("fast_plate_ocr is required for LicensePlateMonitorUseCase but is not installed.")
+
+
+_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:
+        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.")
+        class LicensePlateRecognizer:  # type: ignore
+            """Stub fallback when fast_plate_ocr is not installed."""
+            def __init__(self, *args, **kwargs):
+                print("fast_plate_ocr is required for LicensePlateMonitorUseCase but is not installed.")
 
 # Internal utilities that are still required
 from ..ocr.preprocessing import ImagePreprocessor
@@ -46,6 +65,12 @@ try:
 except Exception as _e:
     print(f"Warning: fast_plate_ocr could not be imported ⇒ {_e}")
 
+try:
+    from  matrice_common.session import Session
+    HAS_MATRICE_SESSION = True
+except ImportError:
+    HAS_MATRICE_SESSION = False
+    logging.warning("Matrice session not available")
 
 @dataclass
 class LicensePlateMonitorConfig(BaseConfig):
@@ -66,7 +91,10 @@ class LicensePlateMonitorConfig(BaseConfig):
     language: List[str] = field(default_factory=lambda: ['en'])
     country: str = field(default_factory=lambda: 'us')
     ocr_mode:str = field(default_factory=lambda: "numeric") # "alphanumeric" or "numeric" or "alphabetic"
-
+    session: Optional[Session] = None
+    lpr_server_id: Optional[str] = None  # Optional LPR server ID for remote logging
+    plate_log_cooldown: float = 30.0  # Cooldown period in seconds for logging same plate
+    
     def validate(self) -> List[str]:
         """Validate configuration parameters."""
         errors = super().validate()
@@ -84,6 +112,149 @@ class LicensePlateMonitorConfig(BaseConfig):
             errors.append("smoothing_confidence_range_factor must be positive")
         return errors
 
+class LicensePlateMonitorLogger:
+    def __init__(self):
+        self.session = None
+        self.logger = logging.getLogger(__name__)
+        self.lpr_server_id = None
+        self.server_info = None
+        self.plate_log_timestamps: Dict[str, float] = {}  # Track last log time per plate
+        self.server_base_url = None
+        self.public_ip = self._get_public_ip()
+
+    def initialize_session(self, config: LicensePlateMonitorConfig) -> None:
+        """Initialize session and fetch server connection info if lpr_server_id is provided."""
+        # Use existing session if provided, otherwise create new one
+        if self.session:
+            return
+        if config.session:
+            self.session = config.session
+        if not self.session:
+            # Initialize Matrice session
+            if not HAS_MATRICE_SESSION:
+                raise ImportError("Matrice session is required for License Plate Monitoring")
+            try:
+                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")
+            except Exception as e:
+                self.logger.error(f"Failed to initialize Matrice session: {e}", exc_info=True)
+                raise
+        
+        # Fetch server connection info if lpr_server_id is provided
+        if config.lpr_server_id:
+            self.lpr_server_id = config.lpr_server_id
+            try:
+                self.server_info = self.get_server_connection_info()
+                if self.server_info:
+                    self.logger.info(f"Successfully fetched LPR server info: {self.server_info.get('name', 'Unknown')}")
+                    # Compare server host with public IP to determine if it's localhost
+                    server_host = self.server_info.get('host', 'localhost')
+                    server_port = self.server_info.get('port', 8200)
+                    
+                    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}")
+                    else:
+                        self.server_base_url = f"https://{server_host}:{server_port}"
+                        self.logger.warning(f"LPR 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', '')}")
+                else:
+                    self.logger.warning("Failed to fetch LPR server connection info")
+            except Exception as e:
+                self.logger.error(f"Error fetching LPR server connection info: {e}", exc_info=True)
+    
+    def _get_public_ip(self) -> str:
+        """Get the public IP address of this machine."""
+        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}")
+            return public_ip
+        except Exception as e:
+            self.logger.error(f"Error fetching external IP: {e}", exc_info=True)
+            return "localhost"
+
+    def get_server_connection_info(self) -> Optional[Dict[str, Any]]:
+        """Fetch server connection info from RPC."""
+        if not self.lpr_server_id:
+            return None
+        
+        try:
+            response = self.session.rpc.get(f"/v1/actions/lpr_servers/{self.lpr_server_id}")
+            if response.get("success", False) and response.get("code") == 200:
+                # Response format:
+                # {'success': True,
+                # 'code': 200,
+                # 'message': 'Success',
+                # 'serverTime': '2025-10-19T04:58:04Z',
+                # 'data': {'id': '68f07e515cd5c6134a075384',
+                # 'name': 'lpr-server-1',
+                # 'host': '106.219.122.19',
+                # 'port': 8200,
+                # 'status': 'created',
+                # 'accountNumber': '3823255831182978487149732',
+                # 'projectID': '68ca6372ab79ba13ef699ba6',
+                # 'region': 'United States',
+                # 'isShared': False}}
+                return response.get("data", {})
+            else:
+                self.logger.warning(f"Failed to fetch server info: {response.get('message', 'Unknown error')}")
+                return None
+        except Exception as e:
+            self.logger.error(f"Exception while fetching server connection info: {e}", exc_info=True)
+            return None
+
+    def should_log_plate(self, plate_text: str, cooldown: float) -> bool:
+        """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)
+        
+        if current_time - last_log_time >= cooldown:
+            return True
+        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()
+
+    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."""
+        # Check cooldown
+        if not self.should_log_plate(plate_text, cooldown):
+            self.logger.debug(f"Plate {plate_text} skipped due to cooldown period")
+            return False
+        
+        try:
+            camera_info = stream_info.get("camera_info", {})
+            camera_name = camera_info.get("camera_name", "")
+            location = camera_info.get("location", "")
+            frame_id = stream_info.get("frame_id", "")
+            
+            payload = {
+                'licensePlate': plate_text,
+                'frameId': frame_id,
+                'location': location,
+                'camera': camera_name,
+                'captureTimestamp': timestamp
+            }
+            
+            await self.session.rpc.post_async('/v1/lpr-server/detections', payload=payload, base_url=self.server_base_url)
+            
+            # Update timestamp after successful log
+            self.update_log_timestamp(plate_text)
+            self.logger.info(f"Successfully logged plate: {plate_text} at {timestamp}")
+            return True
+            
+        except Exception as e:
+            self.logger.error(f"Failed to log plate {plate_text}: {e}", exc_info=True)
+            return False
+        
 class LicensePlateMonitorUseCase(BaseProcessor):
     CATEGORY_DISPLAY = {"license_plate": "license_plate"}
     
@@ -145,6 +316,10 @@ class LicensePlateMonitorUseCase(BaseProcessor):
         self._ocr_mode = None
         #self.jpeg = TurboJPEG()
         
+        # Initialize plate logger (optional, only used if lpr_server_id is provided)
+        self.plate_logger: Optional[LicensePlateMonitorLogger] = None
+        self._logging_enabled = True
+        
 
     def reset_tracker(self) -> None:
         """Reset the advanced tracker instance."""
@@ -170,6 +345,65 @@ class LicensePlateMonitorUseCase(BaseProcessor):
         self.reset_tracker()
         self.reset_plate_tracking()
         self.logger.info("All plate tracking state reset")
+    
+    def _initialize_plate_logger(self, config: LicensePlateMonitorConfig) -> None:
+        """Initialize the plate logger if lpr_server_id is provided."""
+        if not config.lpr_server_id:
+            self._logging_enabled = False
+            self.logger.info("Plate logging disabled: no lpr_server_id provided")
+            return
+        
+        try:
+            if self.plate_logger is None:
+                self.plate_logger = LicensePlateMonitorLogger()
+            
+            self.plate_logger.initialize_session(config)
+            self._logging_enabled = True
+            self.logger.info(f"Plate logging enabled with server ID: {config.lpr_server_id}")
+        except Exception as e:
+            self.logger.error(f"Failed to initialize plate logger: {e}", exc_info=True)
+            self._logging_enabled = False
+    
+    def _log_detected_plates(self, detections: List[Dict[str, Any]], config: LicensePlateMonitorConfig, 
+                            stream_info: Optional[Dict[str, Any]]) -> 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
+        
+        # Get current timestamp
+        current_timestamp = self._get_current_timestamp_str(stream_info, precision=True)
+        
+        # Collect all unique plates from current detections
+        plates_to_log = set()
+        for det in detections:
+            plate_text = det.get('plate_text')
+            if not plate_text:
+                continue
+            plates_to_log.add(plate_text)
+        
+        # Log each unique plate (respecting cooldown)
+        if plates_to_log:
+            try:
+                # Run async logging tasks
+                loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(loop)
+                try:
+                    tasks = []
+                    for plate_text in plates_to_log:
+                        task = self.plate_logger.log_plate(
+                            plate_text=plate_text,
+                            timestamp=current_timestamp,
+                            stream_info=stream_info,
+                            cooldown=config.plate_log_cooldown
+                        )
+                        tasks.append(task)
+                    
+                    # Run all logging tasks concurrently
+                    loop.run_until_complete(asyncio.gather(*tasks, return_exceptions=True))
+                finally:
+                    loop.close()
+            except Exception as e:
+                self.logger.error(f"Error during plate logging: {e}", exc_info=True)
 
     def process(self, data: Any, config: ConfigProtocol, input_bytes: Optional[bytes] = None, 
                 context: Optional[ProcessingContext] = None, stream_info: Optional[Dict[str, Any]] = None) -> ProcessingResult:
@@ -191,6 +425,10 @@ class LicensePlateMonitorUseCase(BaseProcessor):
             print(config)
             print("--------------------------------------")
             
+            # Initialize plate logger if lpr_server_id is provided (optional flow)
+            if config.lpr_server_id and self._logging_enabled:
+                self._initialize_plate_logger(config)
+            
             # Normalize alert_config if provided as a plain dict (JS JSON)
             if isinstance(getattr(config, 'alert_config', None), dict):
                 try:
@@ -287,6 +525,9 @@ class LicensePlateMonitorUseCase(BaseProcessor):
             processed_data = self._update_detections_with_ocr(processed_data, ocr_analysis)
             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)
+            
             # Step 10: Update frame counter
             self._total_frame_counter += 1