matrice-analytics 0.1.3__py3-none-any.whl → 0.1.32__py3-none-any.whl

matrice_analytics/post_processing/face_reg/people_activity_logging.py

@@ -2,6 +2,8 @@ import asyncio
 import logging
 import time
 import threading
+import queue
+import base64
 from typing import Dict, Optional, Set
 import numpy as np
 import cv2
@@ -16,8 +18,8 @@ class PeopleActivityLogging:
         self.face_client = face_client
         self.logger = logging.getLogger(__name__)
 
-        # Queue for processing detections in background
-        self.activity_queue = asyncio.Queue()
+        # 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
@@ -75,14 +77,12 @@ class PeopleActivityLogging:
         """Process activity queue continuously"""
         while self.is_running:
             try:
-                # Process queued detections with timeout
+                # Process queued detections with timeout using thread-safe queue
                 try:
-                    activity_data = await asyncio.wait_for(
-                        self.activity_queue.get(), timeout=20
-                    )
+                    activity_data = self.activity_queue.get(timeout=20)
                     await self._process_activity(activity_data)
                     self.activity_queue.task_done()
-                except asyncio.TimeoutError:
+                except queue.Empty:
                     # Continue loop to check for empty detections
                     continue
 
@@ -135,7 +135,8 @@ class PeopleActivityLogging:
             self.last_detection_time = time.time()
             self.empty_detection_logged = False
 
-            await self.activity_queue.put(activity_data)
+            # 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)
 
@@ -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"]
@@ -180,46 +181,83 @@ class PeopleActivityLogging:
         
         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
 
-            # Store activity data
-            self.logger.info(f"Storing activity data for employee {employee_id}")
-            upload_url = await self.face_client.store_people_activity(
+            # 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 upload_url:
-                self.logger.debug("Successfully stored activity log and fetched upload URL")
-                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("Failed to store activity log")
+                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 storing activity log: {e}", exc_info=True)
-
+            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):
-        _, buffer = cv2.imencode(".jpg", current_frame)
-        frame_bytes = buffer.tobytes()
-
-        upload_success = await self.face_client.upload_image_to_url(
-            frame_bytes, upload_url
-        )
+        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"Successfully uploaded whole frame for employee {employee_id}")
-        else:
-            self.logger.warning("Failed to upload whole frame")
+            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"""

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)

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

@@ -0,0 +1,139 @@
+"""
+Display statistics for a `fast-plate-ocr` dataset.
+"""
+
+from __future__ import annotations
+
+from collections import Counter
+from collections.abc import Sequence
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+
+import click
+import pandas as pd
+from PIL import Image, UnidentifiedImageError
+from rich import box
+from rich.console import Console, Group
+from rich.markup import escape
+from rich.panel import Panel
+from rich.table import Table
+from typing import Optional
+
+from fast_plate_ocr.train.model.config import load_plate_config_from_yaml
+
+# pylint: disable=too-many-locals
+
+console = Console()
+
+
+def _header_shape(path: Path) -> tuple[bool, Optional[tuple[int, int]]]:
+    try:
+        with Image.open(path) as im:
+            im.verify()
+            w, h = im.size
+            return True, (h, w)
+    except (UnidentifiedImageError, OSError):
+        return False, None
+
+
+def _compact_table(title: str, values: Sequence[float]) -> Table:
+    s = pd.Series(values, dtype="float64")
+    desc = s.describe(percentiles=[0.05, 0.5, 0.95])
+    metrics = ["count", "mean", "std", "min", "max", "5%", "50%", "95%"]
+    tbl = Table(title=title, box=box.MINIMAL_DOUBLE_HEAD, pad_edge=False, expand=False)
+    for m in metrics:
+        tbl.add_column(m, justify="right", style="bold")
+    tbl.add_row(*[f"{desc[m]:.2f}" if pd.notna(desc[m]) else "-" for m in metrics])
+    return tbl
+
+
+@click.command(context_settings={"max_content_width": 120})
+@click.option(
+    "--annotations",
+    "-a",
+    required=True,
+    type=click.Path(exists=True, dir_okay=False, file_okay=True, path_type=Path),
+    help="CSV with image_path and plate_text columns.",
+)
+@click.option(
+    "--plate-config-file",
+    "-c",
+    required=True,
+    type=click.Path(exists=True, dir_okay=False, file_okay=True, path_type=Path),
+    help="YAML config so we know alphabet/pad char.",
+)
+@click.option(
+    "--top-chars",
+    default=10,
+    show_default=True,
+    type=int,
+    help="Show N most frequent characters.",
+)
+@click.option(
+    "--workers",
+    default=8,
+    show_default=True,
+    type=int,
+    help="Parallel header reads (0 disables threading).",
+)
+def dataset_stats(annotations: Path, plate_config_file: Path, top_chars: int, workers: int) -> None:
+    """
+    Display statistics for a `fast-plate-ocr` dataset.
+    """
+    plate_config = load_plate_config_from_yaml(plate_config_file)
+
+    df_annots = pd.read_csv(annotations)
+    root = annotations.parent
+    df_annots["image_path"] = df_annots["image_path"].apply(lambda p: str((root / p).resolve()))
+
+    # Plate lengths and char frequencies
+    plate_lengths = df_annots["plate_text"].str.len().tolist()
+    char_counter: Counter[str] = Counter("".join(df_annots["plate_text"].tolist()))
+
+    # File extension counts
+    ext_counter = Counter(df_annots["image_path"].apply(lambda p: Path(p).suffix.lower()))
+
+    # Image header dimensions
+    paths = [Path(p) for p in df_annots["image_path"].tolist()]
+    if workers > 1:
+        with ThreadPoolExecutor(max_workers=workers) as ex:
+            dims = list(ex.map(_header_shape, paths))
+    else:
+        dims = [_header_shape(p) for p in paths]
+
+    valid_dims = [dims_pair for ok, dims_pair in dims if ok and dims_pair is not None]
+
+    heights = [h for h, _ in valid_dims]
+    widths = [w for _, w in valid_dims]
+    aspects = [w / h for h, w in valid_dims if h > 0]
+
+    # Build tables
+    tbl_len = _compact_table("Plate Lengths", plate_lengths)
+    tbl_h = _compact_table("Image Height", heights)
+    tbl_w = _compact_table("Image Width", widths)
+    tbl_ar = _compact_table("Aspect Ratio", aspects)
+
+    # Extension table
+    tbl_ext = Table(title="Extensions", box=box.MINIMAL_DOUBLE_HEAD, pad_edge=False)
+    tbl_ext.add_column("Ext", style="bold", justify="left")
+    tbl_ext.add_column("Count", justify="right")
+    for ext, cnt in ext_counter.most_common():
+        tbl_ext.add_row(ext or "<none>", str(cnt))
+
+    # Character freq table
+    tbl_char = Table(title=f"Top {top_chars} Chars", box=box.MINIMAL_DOUBLE_HEAD, pad_edge=False)
+    tbl_char.add_column("Char", style="bold")
+    tbl_char.add_column("Count", justify="right")
+    for ch, cnt in char_counter.most_common(top_chars):
+        if ch == plate_config.pad_char:
+            continue
+        tbl_char.add_row(escape(ch), str(cnt))
+
+    group = Group(tbl_len, tbl_h, tbl_w, tbl_ar, tbl_ext, tbl_char)
+    console.print(
+        Panel.fit(group, title="Dataset Statistics", border_style="green", box=box.SQUARE)
+    )
+
+
+if __name__ == "__main__":
+    dataset_stats()