matrice-analytics 0.1.60__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

@@ -0,0 +1,270 @@
+import re
+import logging
+
+class TextPostprocessor:
+    def __init__(self, logging_level=logging.INFO):
+        """
+        Initialize the text postprocessor with optional logging configuration.
+        
+        Args:
+            logging_level: The level of logging detail. Default is INFO.
+        """
+        self.logger = logging.getLogger('TextPostprocessor')
+        
+        self.task_processors = {
+            "license_plate": self._process_license_plate,
+            "license_plate_india": self._process_license_plate_india,
+            "license_plate_us": self._process_license_plate_us,
+            "license_plate_eu": self._process_license_plate_eu,
+            "license_plate_qatar": self._process_license_plate_qatar,
+        }
+        
+        self.char_substitutions = {
+            'O': '0',
+            'o': '0',
+            'I': '1',
+            'Z': '2',
+            'A': '4',
+            'L': '1',
+            'AV': 'AV',
+            'S': '5',
+            'B': '8',
+            'D': '0',
+            'Q': '0',
+            'G': '6',
+            'T': '7'
+        }
+
+    def postprocess(self, texts, confidences, task=None, confidence_threshold=0.25, cleanup=True, region=None):
+        """
+        Postprocesses the extracted text by cleaning and filtering low-confidence results.
+        Applies task-specific processing if a task is specified.
+        
+        Args:
+            texts (list): List of extracted text strings.
+            confidences (list): List of confidence scores corresponding to each text.
+            task (str): Specific task for customized postprocessing. Default is None.
+            confidence_threshold (float): Minimum confidence required to keep the text. Default is 0.5.
+            cleanup (bool): Whether to perform text cleanup.
+            region (str): Specific region for license plate processing ('india', 'us', 'eu', 'qatar'). Default is None.
+            
+        Returns:
+            list: List of processed texts with corresponding confidence scores and validity flags.
+        """
+        results = []
+        
+        for text, confidence in zip(texts, confidences):
+            if confidence < confidence_threshold:
+                self.logger.debug(f"Text '{text}' rejected: confidence {confidence} below threshold {confidence_threshold}")
+                results.append((None, confidence, False))
+                continue
+            
+            if cleanup:
+                processed_text = self._clean_text(text)
+            else:
+                processed_text = text
+            
+            if task and processed_text:
+                if task == "license_plate" and region:
+                    region_task = f"license_plate_{region.lower()}"
+                    if region_task in self.task_processors:
+                        processed_text = self.task_processors[region_task](processed_text)
+                    else:
+                        processed_text = self.task_processors["license_plate"](processed_text)
+                        self.logger.warning(f"Region '{region}' not supported, using generic license plate processor")
+                elif task in self.task_processors:
+                    processed_text = self.task_processors[task](processed_text)
+                else:
+                    self.logger.warning(f"Task '{task}' not supported, skipping task-specific processing")
+            
+            if processed_text:
+                self.logger.debug(f"Text processed successfully: '{text}' -> '{processed_text}'")
+                results.append((processed_text, confidence, True))
+            else:
+                self.logger.debug(f"Text '{text}' rejected during processing")
+                results.append((None, confidence, False))
+        
+        return results
+    
+    def _clean_text(self, text):
+        """
+        Basic text cleaning operations.
+        
+        Args:
+            text (str): Text to clean.
+            
+        Returns:
+            str: Cleaned text.
+        """
+        clean_text = text.strip()
+        clean_text = ''.join(char for char in clean_text if char.isprintable())
+        clean_text = ' '.join(clean_text.split())
+        
+        return clean_text
+    
+    def _process_license_plate(self, text):
+        """
+        Generic license plate processor that respects the specified region.
+        
+        Args:
+            text (str): License plate text to process.
+            
+        Returns:
+            str: Processed license plate text or None if invalid.
+        """
+        plate_text = text.upper()
+        plate_text = ''.join(plate_text.split())
+        
+        if self.region and self.region.lower() == 'qatar':
+            return self._process_license_plate_qatar(plate_text)
+        elif self.region and self.region.lower() == 'india':
+            return self._process_license_plate_india(plate_text)
+        elif self.region and self.region.lower() == 'us':
+            return self._process_license_plate_us(plate_text)
+        elif self.region and self.region.lower() == 'eu':
+            return self._process_license_plate_eu(plate_text)
+        else:
+            if re.match(r'^[A-Z]{2}\d{1,2}[A-Z]{1,2}\d{4}$', plate_text):
+                return self._process_license_plate_india(plate_text)
+            elif re.match(r'^[A-Z0-9]{1,8}$', plate_text) and len(plate_text) <= 8:
+                return self._process_license_plate_us(plate_text)
+            elif re.match(r'^[A-Z]{1,3}[-\s]?[A-Z0-9]{1,4}[-\s]?[A-Z0-9]{1,3}$', plate_text):
+                return self._process_license_plate_eu(plate_text)
+            elif re.match(r'^\d{1,6}\s*[A-Z]+?$', plate_text):
+                return self._process_license_plate_qatar(plate_text)
+            else:
+                plate_text = ''.join(char for char in plate_text if char.isalnum())
+                if 4 <= len(plate_text) <= 10:
+                    return plate_text
+        
+        self.logger.warning(f"Could not identify license plate format: '{text}'")
+        return None
+    
+    def _process_license_plate_india(self, text):
+        plate_text = text.upper().replace(" ", "")
+        plate_text = ''.join(char for char in plate_text if char.isalnum())
+        for old, new in self.char_substitutions.items():
+            plate_text = plate_text.replace(old, new)
+        
+        if len(plate_text) >= 7:
+            state_code = plate_text[:2]
+            rest = plate_text[2:]
+            match = re.match(r'^(\d{1,2})[ -]?([A-Z]{1,2})[ -]?(\d{4})$', rest)
+            if match and state_code in ['AN', 'AP', 'AR', 'AS', 'BR', 'CH', 'CG', 'DD', 'DL', 'GA', 'GJ', 'HP', 'HR', 'JH', 'JK', 'KA', 'KL', 'LA', 'LD', 'MH', 'ML', 'MN', 'MP', 'MZ', 'NL', 'OD', 'PB', 'PY', 'RJ', 'SK', 'TN', 'TR', 'TG', 'TS', 'UK', 'UP', 'WB']:
+                district, series, number = match.groups()
+                formatted_plate = f"{state_code}{district}{series}{number}"
+                self.logger.info(f"Processed Indian license plate: '{text}' -> '{formatted_plate}'")
+                return formatted_plate
+        self.logger.warning(f"Invalid Indian license plate format: '{text}'")
+        return None
+
+    def _process_license_plate_us(self, text):
+        plate_text = text.upper()
+        plate_text = ''.join(char for char in plate_text if char.isalnum())
+        
+        for old, new in self.char_substitutions.items():
+            plate_text = plate_text.replace(old, new)
+        
+        if re.match(r'^[A-Z]{3}\d{4}$', plate_text) or re.match(r'^\d{3}[A-Z]{4}$', plate_text):
+            self.logger.info(f"Processed US license plate (standard format): '{text}' -> '{plate_text}'")
+            return plate_text
+        if 2 <= len(plate_text) <= 8 and re.match(r'^[A-Z0-9]+$', plate_text):
+            self.logger.info(f"Processed US license plate (vanity/other format): '{text}' -> '{plate_text}'")
+            return plate_text
+        
+        self.logger.warning(f"Invalid US license plate format: '{text}'")
+        return None
+
+    def _process_license_plate_eu(self, text):
+        plate_text = text.upper()
+        plate_text = ''.join(char for char in plate_text if char.isalnum() or char == '-')
+        
+        if '-' not in plate_text and len(plate_text) > 3:
+            for i in range(1, 4):
+                if i < len(plate_text) and plate_text[i].isdigit() and plate_text[i-1].isalpha():
+                    plate_text = plate_text[:i] + '-' + plate_text[i:]
+                    break
+        
+        for old, new in self.char_substitutions.items():
+            plate_text = plate_text.replace(old, new)
+        
+        if re.match(r'^[A-Z]{1,3}-[A-Z]{1,2}\d{1,4}$', plate_text):
+            self.logger.info(f"Processed German license plate: '{text}' -> '{plate_text}'")
+            return plate_text
+        if re.match(r'^[A-Z]{2}\d{2}[A-Z]{3}$', plate_text):
+            self.logger.info(f"Processed UK license plate: '{text}' -> '{plate_text}'")
+            return plate_text
+        if re.match(r'^[A-Z]{2}-\d{3}-[A-Z]{2}$', plate_text) or re.match(r'^\d{4}[A-Z]{3}$', plate_text):
+            self.logger.info(f"Processed French license plate: '{text}' -> '{plate_text}'")
+            return plate_text
+        if re.match(r'^[A-Z]{2}\d{3}[A-Z]{2}$', plate_text):
+            self.logger.info(f"Processed Italian license plate: '{text}' -> '{plate_text}'")
+            return plate_text
+        if re.match(r'^\d{4}[BCDFGHJKLMNPRSTVWXYZ]{3}$', plate_text):
+            self.logger.info(f"Processed Spanish license plate: '{text}' -> '{plate_text}'")
+            return plate_text
+        if re.search(r'[A-Z]', plate_text) and re.search(r'\d', plate_text) and 4 <= len(plate_text) <= 10:
+            self.logger.info(f"Processed generic European license plate: '{text}' -> '{plate_text}'")
+            return plate_text
+        
+        self.logger.warning(f"Invalid European license plate format: '{text}'")
+        return None
+    
+    def _process_license_plate_qatar(self, text):
+        """
+        Process Qatar license plate text by converting Arabic numerals to Latin and keeping only digits.
+        
+        Args:
+            text (str): License plate text to process.
+            
+        Returns:
+            str: Processed license plate text or None if invalid.
+        """
+        # Check for Unicode escape sequences (e.g., \u0664)
+        if r'\u' in str(text):
+            self.logger.warning(f"Invalid Qatar license plate format: '{text}' contains Unicode escape sequence")
+            return None
+
+        # Define Arabic to Latin numeral mapping
+        arabic_to_latin = str.maketrans('٠١٢٣٤٥٦٧٨٩', '0123456789')
+        
+        # Convert Arabic numerals to Latin and keep only alphanumeric characters
+        plate_text = text.translate(arabic_to_latin)
+        plate_text = ''.join(char for char in plate_text if char.isalnum())
+        
+        # Apply character substitutions for common OCR errors
+        for old, new in self.char_substitutions.items():
+            plate_text = plate_text.replace(old, new)
+        
+        # Keep only digits for Qatar license plates
+        plate_text = ''.join(char for char in plate_text if char.isdigit())
+        
+        # Validate: Ensure the text is 1 to 6 digits
+        if re.match(r'^\d{1,6}$', plate_text):
+            self.logger.info(f"Processed Qatar license plate: '{text}' -> '{plate_text}'")
+            return plate_text
+        
+        self.logger.warning(f"Invalid Qatar license plate format: '{text}'")
+        return None
+    
+    def _string_similarity(self, s1, s2):
+        if len(s1) > len(s2):
+            s1, s2 = s2, s1
+        
+        distances = range(len(s1) + 1)
+        for i2, c2 in enumerate(s2):
+            distances_ = [i2+1]
+            for i1, c1 in enumerate(s1):
+                if c1 == c2:
+                    distances_.append(distances[i1])
+                else:
+                    distances_.append(1 + min((distances[i1], distances[i1 + 1], distances_[-1])))
+            distances = distances_
+        
+        max_len = max(len(s1), len(s2))
+        similarity = 1 - (distances[-1] / max_len if max_len > 0 else 0)
+        return similarity
+    
+    def add_task_processor(self, task_name, processor_function):
+        self.task_processors[task_name] = processor_function
+        self.logger.info(f"Added new task processor: {task_name}")

matrice_analytics/post_processing/ocr/preprocessing.py

@@ -0,0 +1,52 @@
+import cv2
+import numpy as np
+
+class ImagePreprocessor:
+    def __init__(self):
+        """Initialize the image preprocessor"""
+        pass
+    
+    def preprocess(self, image_np, resize_dim=None, grayscale=True):
+        """
+        Preprocesses the image with various operations.
+        
+        Args:
+            image_np (np.ndarray): Input image as a numpy array.
+            resize_dim (tuple): Desired dimensions (width, height). If None, no resizing is done.
+            grayscale (bool): Whether to convert the image to grayscale.
+            
+        Returns:
+            np.ndarray: Preprocessed image.
+        """
+        processed_image = image_np.copy()
+        
+        # Convert to grayscale if requested
+        if grayscale:
+            if len(processed_image.shape) == 3:  # Check if image is already grayscale
+                processed_image = cv2.cvtColor(processed_image, cv2.COLOR_RGB2GRAY)
+        
+        # Resize image if dimensions are provided
+        if resize_dim:
+            processed_image = cv2.resize(processed_image, resize_dim, interpolation=cv2.INTER_LINEAR)
+        
+        return processed_image
+    
+    def crop_to_bboxes(self, image_np, bboxes):
+        """
+        Crops the image to the specified bounding boxes.
+        
+        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].
+            
+        Returns:
+            list: List of cropped images.
+        """
+        cropped_images = []
+        
+        for box in bboxes:
+            xmin, ymin, xmax, ymax = map(int, box)
+            cropped_img = image_np[ymin:ymax, xmin:xmax]
+            cropped_images.append(cropped_img)
+        
+        return cropped_images