matrice-analytics 0.1.60__py3-none-any.whl

matrice_analytics/post_processing/face_reg/people_activity_logging.py

@@ -0,0 +1,321 @@
+import asyncio
+import logging
+import time
+import threading
+import queue
+import base64
+from typing import Dict, Optional, Set
+import numpy as np
+import cv2
+from datetime import datetime, timezone
+from .face_recognition_client import FacialRecognitionClient
+
+
+class PeopleActivityLogging:
+    """Background logging system for face recognition activity"""
+
+    def __init__(self, face_client: FacialRecognitionClient = None):
+        self.face_client = face_client
+        self.logger = logging.getLogger(__name__)
+
+        # Use thread-safe queue for cross-thread communication (Python 3.8 compatibility)
+        self.activity_queue = queue.Queue()
+
+        # Thread for background processing
+        self.processing_thread = None
+        self.is_running = False
+
+        # Empty detection tracking
+        self.last_detection_time = time.time()
+        self.empty_detection_logged = False
+        self.empty_detection_threshold = 10.0  # 10 seconds
+
+        # Storage for unknown faces (for debugging/backup)
+        self.unknown_faces_storage = {}
+
+        # Employee ID tracking with timestamps to prevent duplicate logging
+        # TODO: Make this use track_id or similarity check instead of employee_id for better deduplication
+        self.recent_employee_detections: Dict[str, float] = {}
+        self.employee_detection_threshold = 10.0  # 10 seconds
+
+        # Start background processing
+        self.start_background_processing()
+
+    def start_background_processing(self):
+        """Start the background processing thread"""
+        if not self.is_running:
+            self.is_running = True
+            self.processing_thread = threading.Thread(
+                target=self._run_async_loop, daemon=True
+            )
+            self.processing_thread.start()
+            self.logger.info("Started PeopleActivityLogging background processing")
+
+    def stop_background_processing(self):
+        """Stop the background processing thread"""
+        self.is_running = False
+        if self.processing_thread:
+            self.processing_thread.join(timeout=5.0)
+            self.logger.info("Stopped PeopleActivityLogging background processing")
+
+    def _run_async_loop(self):
+        """Run the async event loop in the background thread"""
+        try:
+            # Create new event loop for this thread
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            loop.run_until_complete(self._process_activity_queue())
+        except Exception as e:
+            self.logger.error(f"Error in background processing loop: {e}", exc_info=True)
+        finally:
+            try:
+                loop.close()
+            except:
+                pass
+
+    async def _process_activity_queue(self):
+        """Process activity queue continuously"""
+        while self.is_running:
+            try:
+                # Process queued detections with timeout using thread-safe queue
+                try:
+                    activity_data = self.activity_queue.get(timeout=20)
+                    await self._process_activity(activity_data)
+                    self.activity_queue.task_done()
+                except queue.Empty:
+                    # Continue loop to check for empty detections
+                    continue
+
+            except Exception as e:
+                self.logger.error(f"Error processing activity queue: {e}", exc_info=True)
+                await asyncio.sleep(1.0)
+
+    async def enqueue_detection(
+        self,
+        detection: Dict,
+        current_frame: Optional[np.ndarray] = None,
+        location: str = "",
+    ):
+        """Enqueue a detection for background processing"""
+        try:
+            activity_data = {
+                "detection_type": detection["recognition_status"],  # known, unknown
+                "detection": detection,
+                "current_frame": current_frame,
+                "location": location,
+                "timestamp": datetime.now(timezone.utc).isoformat(),
+                "employee_id": detection.get("employee_id", None),
+                "staff_id": detection.get("person_id")
+            }
+            if detection["recognition_status"] not in ["known", "unknown"]:
+                self.logger.warning(
+                    f"Invalid detection status: {detection['recognition_status']}"
+                )
+                return
+            if not detection.get("employee_id", None):
+                self.logger.warning(
+                    f"No employee_id found for detection: {detection}"
+                )
+                return
+            if not detection.get("person_id", None):
+                self.logger.warning(
+                    f"No person_id found for detection: {detection}"
+                )
+                return
+
+            bbox = detection.get("bounding_box", {})
+            bbox_list = [
+                bbox.get("xmin", 0),
+                bbox.get("ymin", 0),
+                bbox.get("xmax", 0),
+                bbox.get("ymax", 0),
+            ]
+            activity_data["bbox"] = bbox_list
+            # Update last detection time
+            self.last_detection_time = time.time()
+            self.empty_detection_logged = False
+
+            # Use thread-safe put (no await needed for queue.Queue)
+            self.activity_queue.put(activity_data)
+        except Exception as e:
+            self.logger.error(f"Error enqueueing detection: {e}", exc_info=True)
+
+    def _should_log_detection(self, employee_id: str) -> bool:
+        """
+        Check if detection should be logged based on employee ID and time threshold.
+        Only log if employee_id was not detected in the past 10 seconds.
+        
+        TODO: Make this use track_id or similarity check instead of just employee_id in 10 secs window
+        for better deduplication across different detection sessions.
+        """
+        current_time = time.time()
+        
+        # Clean up old entries (older than threshold)
+        expired_keys = [
+            emp_id for emp_id, timestamp in self.recent_employee_detections.items()
+            if current_time - timestamp > self.employee_detection_threshold
+        ]
+        for emp_id in expired_keys:
+            del self.recent_employee_detections[emp_id]
+        
+        # Check if employee was recently detected
+        if employee_id in self.recent_employee_detections:
+            last_detection = self.recent_employee_detections[employee_id]
+            if current_time - last_detection < self.employee_detection_threshold:
+                self.logger.debug(f"Skipping logging for employee {employee_id} - detected {current_time - last_detection:.1f}s ago")
+                return False
+        
+        # Update detection time for this employee
+        self.recent_employee_detections[employee_id] = current_time
+        return True
+
+    async def _process_activity(self, activity_data: Dict):
+        """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"]
+        employee_id = activity_data["employee_id"]
+        location = activity_data["location"]
+        staff_id = activity_data["staff_id"]
+        timestamp = activity_data["timestamp"]
+        
+        try:
+            if not self.face_client:
+                self.logger.warning("Face client not available for activity logging")
+                return
+
+            # Check if we should log this detection (avoid duplicates within time window)
+            if not self._should_log_detection(employee_id):
+                self.logger.debug(f"Skipping activity log for employee_id={employee_id} (within cooldown period)")
+                return None
+
+            # 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}")
+            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 response and response.get("success", False):
+                self.logger.info(f"Activity log stored successfully for employee_id={employee_id}")
+            else:
+                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 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:
+            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 _should_log_activity(self, activity_data: Dict) -> bool:
+        """Check if activity should be logged"""
+        detection_type = activity_data["detection_type"]
+        if detection_type == "known":
+            return True
+        return False
+
+    def _crop_face_from_frame(self, frame: np.ndarray, bounding_box: Dict) -> bytes:
+        """
+        Crop face from frame using bounding box and return as bytes
+
+        Args:
+            frame: Original frame as numpy array
+            bounding_box: Dict with x1, y1, x2, y2 coordinates
+
+        Returns:
+            bytes: Cropped face image as JPEG bytes
+        """
+        try:
+            # Extract coordinates - handle different bounding box formats
+            x1 = int(bounding_box.get("xmin", bounding_box.get("x1", 0)))
+            y1 = int(bounding_box.get("ymin", bounding_box.get("y1", 0)))
+            x2 = int(bounding_box.get("xmax", bounding_box.get("x2", 0)))
+            y2 = int(bounding_box.get("ymax", bounding_box.get("y2", 0)))
+
+            # Ensure coordinates are within frame bounds
+            h, w = frame.shape[:2]
+            x1, y1 = max(0, x1), max(0, y1)
+            x2, y2 = min(w, x2), min(h, y2)
+
+            # Validate coordinates
+            if x2 <= x1 or y2 <= y1:
+                self.logger.warning("Invalid bounding box coordinates")
+                return b""
+
+            # Crop the face
+            cropped_face = frame[y1:y2, x1:x2]
+
+            # Convert to JPEG bytes
+            _, buffer = cv2.imencode(".jpg", cropped_face)
+            return buffer.tobytes()
+
+        except Exception as e:
+            self.logger.error(f"Error cropping face from frame: {e}", exc_info=True)
+            return b""
+
+    def get_unknown_faces_storage(self) -> Dict[str, bytes]:
+        """Get stored unknown face images as bytes"""
+        return self.unknown_faces_storage.copy()
+
+    def clear_unknown_faces_storage(self) -> None:
+        """Clear stored unknown face images"""
+        self.unknown_faces_storage.clear()
+
+    def __del__(self):
+        """Cleanup when object is destroyed"""
+        try:
+            self.stop_background_processing()
+        except:
+            pass

matrice_analytics/post_processing/ocr/easyocr_extractor.py

@@ -0,0 +1,250 @@
+import easyocr
+import numpy as np
+import torch
+from matrice_common.utils import log_errors
+
+class EasyOCRExtractor:
+    def __init__(self, lang=['en', 'hi', 'ar'], gpu=False, model_storage_directory=None, 
+                 download_enabled=True, detector=True, recognizer=True, verbose=False):
+        """
+        Initializes the EasyOCR text extractor with optimized parameters.
+        
+        Args:
+            lang (str or list): Language(s) to be used by EasyOCR. Default is ['en', 'hi', 'ar'].
+            gpu (bool): Enable GPU acceleration if available. Default is True.
+            model_storage_directory (str): Custom path to store models. Default is None.
+            download_enabled (bool): Allow downloading models if not found. Default is True.
+            detector (bool): Load text detection model. Default is True.
+            recognizer (bool): Load text recognition model. Default is True.
+            verbose (bool): Enable verbose output (e.g., progress bars). Default is False.
+        """
+        self.lang = lang
+        self.gpu = gpu
+        # Check if GPU is available
+        if torch.cuda.is_available():
+            self.gpu = True
+        else:
+            self.gpu = False
+        self.model_storage_directory = model_storage_directory
+        self.download_enabled = download_enabled
+        self.detector = detector
+        self.recognizer = recognizer
+        self.verbose = verbose
+        self.reader = None
+        
+    @log_errors(default_return=None, raise_exception=True, service_name="py_analytics", log_error=True)
+    def setup(self):
+        """
+        Initializes the EasyOCR reader if not already initialized.
+        """
+        if self.reader is None:
+            lang_list = [self.lang] if isinstance(self.lang, str) else self.lang
+            self.reader = easyocr.Reader(
+                lang_list=lang_list,
+                gpu=self.gpu,
+                model_storage_directory=self.model_storage_directory,
+                download_enabled=self.download_enabled,
+                detector=self.detector,
+                recognizer=self.recognizer,
+                verbose=self.verbose
+            )
+    
+    def extract(self, image_np, bboxes=None, detail=1, paragraph=False, 
+                decoder='greedy', beam_width=5, batch_size=1, workers=0,
+                allowlist=None, blocklist=None, min_size=10, rotation_info=None,
+                contrast_ths=0.1, adjust_contrast=0.5, text_threshold=0.7,
+                low_text=0.4, link_threshold=0.4, canvas_size=2560, mag_ratio=1.0,
+                slope_ths=0.1, ycenter_ths=0.5, height_ths=0.5, width_ths=0.5,
+                add_margin=0.1):
+        """
+        Extracts text from the given image or specific regions within the bounding boxes
+        with configurable parameters for optimal performance.
+        
+        Args:
+            image_np (np.ndarray): Input image as a numpy array.
+            bboxes (list): List of bounding boxes. Each box is a list of [xmin, ymin, xmax, ymax].
+                          If None, OCR is performed on the entire image.
+            detail (int): Set to 0 for simple output, 1 for detailed output.
+            paragraph (bool): Combine results into paragraphs.
+            decoder (str): Decoding method ('greedy', 'beamsearch', 'wordbeamsearch').
+            beam_width (int): How many beams to keep when using beam search decoders.
+            batch_size (int): Number of images to process in a batch.
+            workers (int): Number of worker threads for data loading.
+            allowlist (str): Force recognition of only specific characters.
+            blocklist (str): Block specific characters from recognition.
+            min_size (int): Filter text boxes smaller than this pixel size.
+            rotation_info (list): List of rotation angles to try (e.g., [90, 180, 270]).
+            contrast_ths (float): Threshold for contrast adjustment.
+            adjust_contrast (float): Target contrast level for low-contrast text.
+            text_threshold (float): Text confidence threshold.
+            low_text (float): Text low-bound score.
+            link_threshold (float): Link confidence threshold.
+            canvas_size (int): Maximum image size before resizing.
+            mag_ratio (float): Image magnification ratio.
+            slope_ths (float): Maximum slope for merging boxes.
+            ycenter_ths (float): Maximum y-center shift for merging boxes.
+            height_ths (float): Maximum height difference for merging boxes.
+            width_ths (float): Maximum width for horizontal merging.
+            add_margin (float): Margin to add around text boxes.
+            
+        Returns:
+            list: OCR results containing text, confidence, and bounding boxes.
+        """
+        # Make sure the reader is initialized
+        self.setup()
+        
+        ocr_results = []
+        
+        # Dictionary of readtext parameters
+        readtext_params = {
+            'decoder': decoder,
+            'beamWidth': beam_width,
+            'batch_size': batch_size,
+            'workers': workers,
+            'allowlist': allowlist,
+            'blocklist': blocklist,
+            'detail': detail,
+            'paragraph': paragraph,
+            'min_size': min_size,
+            'rotation_info': rotation_info,
+            'contrast_ths': contrast_ths,
+            'adjust_contrast': adjust_contrast,
+            'text_threshold': text_threshold,
+            'low_text': low_text,
+            'link_threshold': link_threshold,
+            'canvas_size': canvas_size,
+            'mag_ratio': mag_ratio,
+            'slope_ths': slope_ths,
+            'ycenter_ths': ycenter_ths,
+            'height_ths': height_ths,
+            'width_ths': width_ths,
+            'add_margin': add_margin
+        }
+        
+        # If no bounding boxes, perform OCR on the entire image
+        if bboxes is None:
+            text_data = self.reader.readtext(image_np, **readtext_params)
+            if detail == 0:
+                return text_data  # Simple output format for detail=0
+            
+            for bbox, text, conf in text_data:
+                ocr_results.append({
+                    "text": text,
+                    "confidence": conf,
+                    "bounding_box": bbox
+                })
+        else:
+            # Perform OCR on each bounding box
+            for box in bboxes:
+                xmin, ymin, xmax, ymax = map(int, box)
+                cropped_img = image_np[ymin:ymax, xmin:xmax]
+                
+                # Skip empty crops
+                if cropped_img.size == 0 or cropped_img.shape[0] == 0 or cropped_img.shape[1] == 0:
+                    continue
+                
+                text_data = self.reader.readtext(cropped_img, **readtext_params)
+                
+                if detail == 0:
+                    # Adjust coordinates for the cropped region
+                    adjusted_data = []
+                    for result in text_data:
+                        if isinstance(result, tuple) and len(result) >= 1:
+                            # Adjust coordinates based on crop position
+                            adjusted_bbox = [[pt[0] + xmin, pt[1] + ymin] for pt in result[0]]
+                            if len(result) == 3:  # (bbox, text, confidence)
+                                adjusted_data.append((adjusted_bbox, result[1], result[2]))
+                            elif len(result) == 2:  # (bbox, text)
+                                adjusted_data.append((adjusted_bbox, result[1]))
+                    ocr_results.extend(adjusted_data)
+                else:
+                    for bbox, text, conf in text_data:
+                        # Adjust bounding box coordinates relative to the original image
+                        adjusted_bbox = [
+                            [pt[0] + xmin, pt[1] + ymin] for pt in bbox
+                        ]
+                        
+                        ocr_results.append({
+                            "text": text,
+                            "confidence": conf,
+                            "bounding_box": adjusted_bbox
+                        })
+        
+        return ocr_results
+    
+    def detect_text_regions(self, image_np, min_size=10, text_threshold=0.7,
+                            low_text=0.4, link_threshold=0.4, canvas_size=2560,
+                            mag_ratio=1.0, slope_ths=0.1, ycenter_ths=0.5,
+                            height_ths=0.5, width_ths=0.5, add_margin=0.1,
+                            optimal_num_chars=None):
+        """
+        Detects text regions in the image without performing recognition.
+        
+        Args:
+            image_np (np.ndarray): Input image as a numpy array.
+            min_size (int): Filter text boxes smaller than this pixel size.
+            text_threshold (float): Text confidence threshold.
+            low_text (float): Text low-bound score.
+            link_threshold (float): Link confidence threshold.
+            canvas_size (int): Maximum image size before resizing.
+            mag_ratio (float): Image magnification ratio.
+            slope_ths (float): Maximum slope for merging boxes.
+            ycenter_ths (float): Maximum y-center shift for merging boxes.
+            height_ths (float): Maximum height difference for merging boxes.
+            width_ths (float): Maximum width for horizontal merging.
+            add_margin (float): Margin to add around text boxes.
+            optimal_num_chars (int): Prioritize boxes with this estimated character count.
+            
+        Returns:
+            tuple: (horizontal_list, free_list) containing text regions
+        """
+        self.setup()
+        return self.reader.detect(
+            image_np,
+            min_size=min_size,
+            text_threshold=text_threshold,
+            low_text=low_text,
+            link_threshold=link_threshold,
+            canvas_size=canvas_size,
+            mag_ratio=mag_ratio,
+            slope_ths=slope_ths,
+            ycenter_ths=ycenter_ths,
+            height_ths=height_ths,
+            width_ths=width_ths,
+            add_margin=add_margin,
+            optimal_num_chars=optimal_num_chars
+        )
+    
+    def recognize_from_regions(self, image_np, horizontal_list=None, free_list=None,
+                               decoder='greedy', beam_width=5, batch_size=1,
+                               workers=0, allowlist=None, blocklist=None,
+                               detail=1, paragraph=False, contrast_ths=0.1,
+                               adjust_contrast=0.5):
+        """
+        Recognizes text from previously detected regions.
+        
+        Args:
+            image_np (np.ndarray): Input image as a numpy array.
+            horizontal_list (list): List of rectangular regions [x_min, x_max, y_min, y_max].
+            free_list (list): List of free-form regions [[x1,y1],[x2,y2],[x3,y3],[x4,y4]].
+            Other parameters: Same as extract method.
+            
+        Returns:
+            list: OCR results for the specified regions
+        """
+        self.setup()
+        return self.reader.recognize(
+            image_np,
+            horizontal_list=horizontal_list,
+            free_list=free_list,
+            decoder=decoder,
+            beamWidth=beam_width,
+            batch_size=batch_size,
+            workers=workers,
+            allowlist=allowlist,
+            blocklist=blocklist,
+            detail=detail,
+            paragraph=paragraph,
+            contrast_ths=contrast_ths,
+            adjust_contrast=adjust_contrast
+        )

matrice_analytics/post_processing/ocr/fast_plate_ocr_py38/__init__.py

@@ -0,0 +1,9 @@
+"""
+Fast Plate OCR package.
+"""
+
+from __future__ import annotations
+
+from fast_plate_ocr.inference.plate_recognizer import LicensePlateRecognizer
+
+__all__ = ["LicensePlateRecognizer"]

matrice_analytics/post_processing/ocr/fast_plate_ocr_py38/cli/__init__.py

@@ -0,0 +1,4 @@
+from __future__ import annotations
+
+"""CLI utilities for Fast Plate OCR (Python 3.8 compatible)."""
+

matrice_analytics/post_processing/ocr/fast_plate_ocr_py38/cli/cli.py

@@ -0,0 +1,33 @@
+"""
+Main CLI used when training a FastPlateOCR model.
+"""
+
+from __future__ import annotations
+
+try:
+    import click
+
+    from fast_plate_ocr.cli.dataset_stats import dataset_stats
+    from fast_plate_ocr.cli.export import export
+    from fast_plate_ocr.cli.train import train
+    from fast_plate_ocr.cli.valid import valid
+    from fast_plate_ocr.cli.validate_dataset import validate_dataset
+    from fast_plate_ocr.cli.visualize_augmentation import visualize_augmentation
+    from fast_plate_ocr.cli.visualize_predictions import visualize_predictions
+
+except ImportError as e:
+    raise ImportError("Make sure to 'pip install fast-plate-ocr[train]' to run this!") from e
+
+
+@click.group(context_settings={"max_content_width": 120})
+def main_cli():
+    """FastPlateOCR CLI."""
+
+
+main_cli.add_command(dataset_stats)
+main_cli.add_command(export)
+main_cli.add_command(train)
+main_cli.add_command(valid)
+main_cli.add_command(validate_dataset)
+main_cli.add_command(visualize_augmentation)
+main_cli.add_command(visualize_predictions)