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

matrice_analytics/post_processing/ocr/fast_plate_ocr_py38/train/utilities/utils.py

@@ -0,0 +1,214 @@
+"""
+Utility functions module
+"""
+
+import logging
+import pathlib
+import pkgutil
+import random
+from collections.abc import Iterator
+from importlib import import_module
+from typing import Optional, Union
+
+import cv2
+import keras
+import numpy as np
+import numpy.typing as npt
+
+from fast_plate_ocr.core.process import read_and_resize_plate_image
+from fast_plate_ocr.core.types import ImageColorMode, ImageInterpolation, PaddingColor
+from fast_plate_ocr.train.model.config import PlateOCRConfig
+from fast_plate_ocr.train.model.loss import cce_loss, focal_cce_loss
+from fast_plate_ocr.train.model.metric import (
+    cat_acc_metric,
+    plate_acc_metric,
+    plate_len_acc_metric,
+    top_3_k_metric,
+)
+
+
+def one_hot_plate(plate: str, alphabet: str) -> list[list[int]]:
+    return [[0 if char != letter else 1 for char in alphabet] for letter in plate]
+
+
+def target_transform(
+    plate_text: str,
+    max_plate_slots: int,
+    alphabet: str,
+    pad_char: str,
+) -> npt.NDArray[np.uint8]:
+    # Pad the plates which length is smaller than 'max_plate_slots'
+    plate_text = plate_text.ljust(max_plate_slots, pad_char)
+    # Generate numpy arrays with one-hot encoding of plates
+    encoded_plate = np.array(one_hot_plate(plate_text, alphabet=alphabet), dtype=np.uint8)
+    return encoded_plate
+
+
+def _register_custom_keras():
+    base_pkg = "fast_plate_ocr.train.model"
+    for _, name, _ in pkgutil.walk_packages(
+        import_module(base_pkg).__path__, prefix=f"{base_pkg}."
+    ):
+        if any(m in name for m in ("layers",)):
+            import_module(name)
+
+
+def load_keras_model(
+    model_path: Union[str, pathlib.Path],
+    plate_config: PlateOCRConfig,
+) -> keras.Model:
+    """
+    Utility helper function to load the keras OCR model.
+    """
+    _register_custom_keras()
+    custom_objects = {
+        "cce": cce_loss(
+            vocabulary_size=plate_config.vocabulary_size,
+        ),
+        "focal_cce": focal_cce_loss(
+            vocabulary_size=plate_config.vocabulary_size,
+        ),
+        "cat_acc": cat_acc_metric(
+            max_plate_slots=plate_config.max_plate_slots,
+            vocabulary_size=plate_config.vocabulary_size,
+        ),
+        "plate_acc": plate_acc_metric(
+            max_plate_slots=plate_config.max_plate_slots,
+            vocabulary_size=plate_config.vocabulary_size,
+        ),
+        "top_3_k": top_3_k_metric(
+            vocabulary_size=plate_config.vocabulary_size,
+        ),
+        "plate_len_acc": plate_len_acc_metric(
+            max_plate_slots=plate_config.max_plate_slots,
+            vocabulary_size=plate_config.vocabulary_size,
+            pad_token_index=plate_config.pad_idx,
+        ),
+    }
+    model = keras.models.load_model(model_path, custom_objects=custom_objects)
+    return model
+
+
+IMG_EXTENSIONS: set[str] = {".jpg", ".jpeg", ".png", ".bmp", ".gif", ".tiff", ".webp"}
+"""Valid image extensions for the scope of this script."""
+
+
+def load_images_from_folder(  # noqa: PLR0913
+    img_dir: pathlib.Path,
+    width: int,
+    height: int,
+    image_color_mode: ImageColorMode = "grayscale",
+    keep_aspect_ratio: bool = False,
+    interpolation_method: ImageInterpolation = "linear",
+    padding_color: PaddingColor = (114, 114, 114),
+    shuffle: bool = False,
+    limit: Optional[int] = None,
+) -> Iterator[npt.NDArray]:
+    """
+    Return all images read from a directory. This uses the same read function used during training.
+    """
+    # pylint: disable=too-many-arguments
+    image_paths = sorted(
+        str(f.resolve()) for f in img_dir.iterdir() if f.is_file() and f.suffix in IMG_EXTENSIONS
+    )
+    if limit:
+        image_paths = image_paths[:limit]
+    if shuffle:
+        random.shuffle(image_paths)
+    yield from (
+        read_and_resize_plate_image(
+            i,
+            img_height=height,
+            img_width=width,
+            image_color_mode=image_color_mode,
+            keep_aspect_ratio=keep_aspect_ratio,
+            interpolation_method=interpolation_method,
+            padding_color=padding_color,
+        )
+        for i in image_paths
+    )
+
+
+def postprocess_model_output(
+    prediction: npt.NDArray,
+    alphabet: str,
+    max_plate_slots: int,
+    vocab_size: int,
+) -> tuple[str, npt.NDArray]:
+    """
+    Return plate text and confidence scores from raw model output.
+    """
+    prediction = prediction.reshape((max_plate_slots, vocab_size))
+    probs = np.max(prediction, axis=-1)
+    prediction = np.argmax(prediction, axis=-1)
+    plate = "".join([alphabet[x] for x in prediction])
+    return plate, probs
+
+
+def low_confidence_positions(probs, thresh=0.3) -> npt.NDArray:
+    """Returns indices of elements in `probs` less than `thresh`, indicating low confidence."""
+    return np.where(np.array(probs) < thresh)[0]
+
+
+def display_predictions(
+    image: npt.NDArray,
+    plate: str,
+    probs: npt.NDArray,
+    low_conf_thresh: float,
+) -> None:
+    """
+    Display plate and corresponding prediction.
+    """
+    plate_str = "".join(plate)
+    logging.info("Plate: %s", plate_str)
+    logging.info("Confidence: %s", probs)
+    image_to_show = cv2.resize(image, None, fx=3, fy=3, interpolation=cv2.INTER_LINEAR)
+    if len(image_to_show.shape) == 2:
+        image_to_show = cv2.cvtColor(image_to_show, cv2.COLOR_GRAY2RGB)
+    elif image_to_show.shape[2] == 3:
+        image_to_show = cv2.cvtColor(image_to_show, cv2.COLOR_BGR2RGB)
+    # Average probabilities
+    avg_prob = np.mean(probs) * 100
+    cv2.putText(
+        image_to_show,
+        f"{plate_str}  {avg_prob:.{2}f}%",
+        org=(5, 30),
+        fontFace=cv2.FONT_HERSHEY_SIMPLEX,
+        fontScale=1,
+        color=(0, 0, 0),
+        lineType=1,
+        thickness=6,
+    )
+    cv2.putText(
+        image_to_show,
+        f"{plate_str}  {avg_prob:.{2}f}%",
+        org=(5, 30),
+        fontFace=cv2.FONT_HERSHEY_SIMPLEX,
+        fontScale=1,
+        color=(255, 255, 255),
+        lineType=1,
+        thickness=2,
+    )
+    # Display character with low confidence
+    low_conf_chars = "Low conf. on: " + " ".join(
+        [plate[i] for i in low_confidence_positions(probs, thresh=low_conf_thresh)]
+    )
+    cv2.putText(
+        image_to_show,
+        low_conf_chars,
+        org=(5, 200),
+        fontFace=cv2.FONT_HERSHEY_SIMPLEX,
+        fontScale=0.7,
+        color=(0, 0, 220),
+        lineType=1,
+        thickness=2,
+    )
+    try:
+        cv2.imshow("plates", image_to_show)
+        if cv2.waitKey(0) & 0xFF == ord("q"):
+            return
+    except cv2.error as e:  # pylint: disable=catching-non-exception
+        raise RuntimeError(  # pylint: disable=bad-exception-cause
+            "This visualization requires full OpenCV with GUI support. "
+            "Install with `pip install opencv-python` instead of headless."
+        ) from e

matrice_analytics/post_processing/ocr/postprocessing.py

@@ -9,7 +9,6 @@ class TextPostprocessor:
         Args:
             logging_level: The level of logging detail. Default is INFO.
         """
-        logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', level=logging_level)
         self.logger = logging.getLogger('TextPostprocessor')
         
         self.task_processors = {

matrice_analytics/post_processing/post_processor.py

@@ -312,6 +312,7 @@ class PostProcessor:
     ) -> None:
         """Remove parameters that aren't needed for specific use cases."""
         facial_recognition_usecases = {"face_recognition"}
+        license_plate_monitoring_usecases = {"license_plate_monitor"}
         
         if usecase not in facial_recognition_usecases:
             if "facial_recognition_server_id" in config_params:
@@ -319,7 +320,15 @@ 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:
+                logging.debug(f"Removing lpr_server_id from {usecase} config")
+                config_params.pop("lpr_server_id", None)
+        
+        # Keep session and lpr_server_id only for use cases that need them
+        if usecase not in facial_recognition_usecases and usecase not in license_plate_monitoring_usecases:
             if "session" in config_params:
                 logging.debug(f"Removing session from {usecase} config")
                 config_params.pop("session", None)
@@ -634,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
     ):
         """
@@ -660,8 +669,15 @@ class PostProcessor:
         if not use_case_class:
             raise ValueError(f"Use case '{config.category}/{config.usecase}' not found")
 
-        # Instantiate use case
-        use_case = use_case_class()
+        
+        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}")
+
 
         # Cache the instance
         self._use_case_cache[cache_key] = use_case
@@ -689,7 +705,8 @@ class PostProcessor:
             FlareAnalysisUseCase,
             LicensePlateMonitorUseCase,
             AgeGenderUseCase,
-            PeopleTrackingUseCase
+            PeopleTrackingUseCase,
+            FaceRecognitionEmbeddingUseCase
         }
         
         # Async use cases
@@ -745,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:
@@ -1017,7 +1038,7 @@ class PostProcessor:
             "total_processing_time": 0.0,
         }
 
-    def _parse_config(
+    def _parse_config( # TODO: remove all of the kwargs that are not in the use case config
         self, config: Union[BaseConfig, Dict[str, Any], str, Path]
     ) -> BaseConfig:
         """Parse configuration from various input formats."""

matrice_analytics/post_processing/usecases/color/clip.py

@@ -1,23 +1,45 @@
+import requests
+import sys
+from pathlib import Path
+import logging
+import subprocess
+import shutil
+import os
+log_file = open("pip_jetson_bti.log", "w")
+cmd = ["pip", "install", "importlib-resources"]
+subprocess.run(
+        cmd,
+        stdout=log_file,
+        stderr=subprocess.STDOUT,
+        preexec_fn=os.setpgrp   
+    )
+cmd = ["pip", "install", "httpx", "aiohttp", "filterpy"]
+subprocess.run(
+        cmd,
+        stdout=log_file,
+        stderr=subprocess.STDOUT,
+        preexec_fn=os.setpgrp   
+    )
+log_file.close()
+
 import numpy as np
 from typing import List, Dict, Tuple, Optional
 from dataclasses import dataclass, field
-from pathlib import Path
 import cv2
-import os
 import io
 import threading
-# from scipy.special import softmax
-import requests
+import onnxruntime as ort
+from PIL import Image
+
+
 try:
     from transformers import CLIPProcessor
-    import onnxruntime as ort
-    from PIL import Image
+    print("transformers imported successfully")
     from importlib.resources import files as ir_files, as_file as ir_as_file
-
 except:
     ir_files = None
     ir_as_file = None
-    print("Unable to import onnxruntime")
+    print("Unable to import transformers/irlib-resources @ clip.py")
 
 def load_model_from_checkpoint(checkpoint_url: str, providers: Optional[List] = None):
     """
@@ -97,11 +119,22 @@ class ClipProcessor:
         cwd = os.getcwd()
         print("Current working directory:", cwd)
 
+        log_file = open("pip_jetson_bti.log", "w")
+        cmd = ["pip", "install", "--force-reinstall", "huggingface_hub", "regex", "safetensors"]
+        subprocess.Popen(
+                cmd,
+                stdout=log_file,
+                stderr=subprocess.STDOUT,
+                preexec_fn=os.setpgrp   
+            )
+
         # Determine and enforce providers (prefer CUDA only)
         try:
             available = ort.get_available_providers()
         except Exception:
+            print("You are seein this error because of ort :(")
             available = []
+        print("True OG Available ONNX providers:", available, 'providers(if any):',providers)
 
         if providers is None:
             if "CUDAExecutionProvider" in available:
@@ -114,6 +147,7 @@ class ClipProcessor:
 
         # Thread-safety to serialize processing
         self._lock = threading.Lock()
+        print("Curr Providersss: ",self.providers)
 
         self.image_sess = load_model_from_checkpoint(self.image_url, providers=self.providers)
         self.text_sess = load_model_from_checkpoint(self.text_url, providers=self.providers)

matrice_analytics/post_processing/usecases/color/color_mapper.py

@@ -9,7 +9,7 @@ from datetime import datetime, timedelta
 import logging
 
 # Import your existing color extraction functions
-from color_map_utils import extract_major_colors
+#from color_map_utils import extract_major_colors
 
 # Configure logging
 logger = logging.getLogger(__name__)
@@ -163,7 +163,7 @@ class VideoColorClassifier:
                 continue
             
             # Extract colors
-            major_colors = extract_major_colors(cropped_obj, k=self.top_k_colors)
+            major_colors = [()] #extract_major_colors(cropped_obj, k=self.top_k_colors)
             main_color = major_colors[0][0] if major_colors else "unknown"
             
             # Create detailed result entry

matrice_analytics/post_processing/usecases/color_detection.py

@@ -15,7 +15,6 @@ from ..utils import (
     filter_by_categories, 
     apply_category_mapping, 
     match_results_structure,
-    extract_major_colors,
     count_objects_by_category,
     calculate_counting_summary,
     match_results_structure,
@@ -26,7 +25,11 @@ from ..utils import (
 )
 from ..utils.geometry_utils import get_bbox_center, point_in_polygon, get_bbox_bottom25_center
 from ..usecases.color.clip import ClipProcessor
-#from turbojpeg import TurboJPEG, TJPF_RGB
+import sys
+from pathlib import Path
+import logging
+import subprocess
+import shutil
 
 @dataclass
 class ColorDetectionConfig(BaseConfig):
@@ -83,16 +86,16 @@ 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]]]] = field(
-    default_factory=lambda: {
-        "zones": {
-            "Interest_Region": [[86, 328], [844, 317], [1277, 520], [1273, 707], [125, 713]],
-        }
-    }
-)
+    zone_config: Optional[Dict[str, List[List[float]]]] = None #field(
+#     default_factory=lambda: {
+#         "zones": {
+#             "Interest_Region": [[86, 328], [844, 317], [1277, 520], [1273, 707], [125, 713]],
+#         }
+#     }
+# )
     # true_import: bool = False
 
     def validate(self) -> List[str]:
@@ -113,16 +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.
-        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):
@@ -170,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 = {}
@@ -282,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,
@@ -669,95 +679,6 @@ class ColorDetectionUseCase(BaseProcessor):
                 return True
         return False
 
-    def _analyze_colors_in_video(
-        self,
-        data: Any,
-        video_bytes: bytes,
-        config: ColorDetectionConfig
-    ) -> List[Dict[str, Any]]:
-        with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as temp_video:
-            temp_video.write(video_bytes)
-            video_path = temp_video.name
-
-        try:
-            cap = cv2.VideoCapture(video_path)
-            if not cap.isOpened():
-                raise RuntimeError("Failed to open video file")
-
-            fps = config.fps or cap.get(cv2.CAP_PROP_FPS)
-            width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
-            height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-
-            color_analysis = []
-            frame_id = 0
-
-            while True:
-                ret, frame = cap.read()
-                if not ret:
-                    break
-
-                if frame_id % config.frame_skip != 0:
-                    frame_id += 1
-                    continue
-
-                frame_key = str(frame_id)
-                timestamp = frame_id / fps
-                frame_detections = self._get_frame_detections(data, frame_key)
-                if not frame_detections:
-                    frame_id += 1
-                    continue
-
-                rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-
-                for detection in frame_detections:
-                    if detection.get("confidence", 1.0) < config.confidence_threshold:
-                        continue
-
-                    bbox = detection.get("bounding_box", detection.get("bbox"))
-                    if not bbox:
-                        continue
-
-                    # Check all zones
-                    zones = config.zone_config['zones'] if config.zone_config else {}
-                    in_any_zone = not zones  # Process all if no zones
-                    zone_name = None
-                    for z_name, zone_polygon in zones.items():
-                        if self._is_in_zone(bbox, zone_polygon):
-                            in_any_zone = True
-                            zone_name = z_name
-                            break
-                    if not in_any_zone:
-                        continue  # Skip detections outside zones
-
-                    crop = self._crop_bbox(rgb_frame, bbox, config.bbox_format)
-                    if crop.size == 0:
-                        continue
-
-                    major_colors = extract_major_colors(crop, k=config.top_k_colors)
-                    main_color = major_colors[0][0] if major_colors else "unknown"
-
-                    color_record = {
-                        "frame_id": frame_key,
-                        "timestamp": round(timestamp, 2),
-                        "category": detection.get("category", "unknown"),
-                        "confidence": round(detection.get("confidence", 0.0), 3),
-                        "main_color": main_color,
-                        "major_colors": major_colors,
-                        "bbox": bbox,
-                        "detection_id": detection.get("id", f"det_{len(color_analysis)}"),
-                        "track_id": detection.get("track_id"),
-                        "zone_name": zone_name
-                    }
-                    color_analysis.append(color_record)
-
-                frame_id += 1
-
-            cap.release()
-            return color_analysis
-
-        finally:
-            if os.path.exists(video_path):
-                os.unlink(video_path)
 
     def _analyze_colors_in_image(
         self,