input_process_config.py Source File

input_process_config.py Source File#

Mobilint SDK qb Compiler: input_process_config.py Source File
Mobilint SDK qb Compiler v1.0
MCS002-EN
from typing import Dict, List, Any, Optional
from typeguard import typechecked
from . import ConfigABC
 
 
 
class Uint8InputConfig(ConfigABC):
    """
    @brief Configuration for uint8 input handling.
 
    @details Defines whether inputs should be treated as uint8 and which specific inputs to apply this to.
    """
 
    optional = True
    DEFAULTS = {
        "apply": False,
        "inputs": [],
    }
 
    py_to_cpp_name = {
        "apply": "apply",
    }
 
    min_max_check = {}
 
    @typechecked
    def __init__(
        self,
        apply: bool,
        inputs: List[str],
        optional: bool = optional,
    ):
        """
        @brief Initialize the Uint8InputConfig.
        @param apply bool. If true, treat specified inputs as uint8.
        @param inputs List[str]. List of input names to treat as uint8. If empty and apply is true, applies to all inputs.
        @param optional bool. Indicates whether this config is optional. Use the default value defined as a class variable.
        """
        super().__init__(optional)
        self.apply = apply
        self.inputs = inputs
        self.check_valid(except_list=["optional", "inputs"])
 
    @classmethod
    def default_config(cls):
        return cls(**cls.DEFAULTS, optional=cls.optional)
 
    @classmethod
    def from_dict(cls, config_dict: dict):
        """Create Uint8InputConfig from dictionary (JSON structure)"""
        params = cls.DEFAULTS.copy()
 
        if "apply" in config_dict:
            params["apply"] = config_dict["apply"]
        if "inputs" in config_dict:
            params["inputs"] = config_dict["inputs"]
 
        return cls(**params)
 
    def to_dict(self):
        return {
            "apply": self.apply,
            "inputs": self.inputs,
        }
 
 
def get_uint8_input_config(**kwargs) -> Uint8InputConfig:
    """
    @brief Create Uint8InputConfig with partial parameters merged with defaults.
    """
    params = Uint8InputConfig.DEFAULTS.copy()
    params.update(kwargs)
    return Uint8InputConfig(**params, optional=Uint8InputConfig.optional)
 
 
class PreprocessingConfig(ConfigABC):
    """
    @brief Configuration for input preprocessing pipeline.
 
    @details Defines preprocessing operations to be applied to model inputs,
    including operations like resize, normalize, color conversion, etc.
    """
 
    optional = True
    DEFAULTS = {
        "apply": False,
        "auto_convert_format": False,
        "pipeline": [],
        "input_configs": {},
    }
 
    py_to_cpp_name = {
        "apply": "apply",
        "auto_convert_format": "autoConvertFormat",
    }
 
    min_max_check = {}
 
    @typechecked
    def __init__(
        self,
        apply: bool,
        auto_convert_format: bool,
        pipeline: List[Dict[str, Any]],
        input_configs: Dict[str, Any],
        optional: bool = optional,
    ):
        """
        @brief Initialize the PreprocessingConfig.
        @param apply bool. If true, apply preprocessing pipeline.
        @param auto_convert_format bool. If true, automatically convert input format.
        @param pipeline List[Dict[str, Any]]. List of preprocessing operations to apply globally.
            Each operation is a dict with "op" key and operation-specific parameters.
            Supported operations: colorConvert, resize, centerCrop, pad, letterbox,
            normalize, clamp, divideByScale, multiplyByScale, reshape, transpose, permute.
        @param input_configs Dict[str, Any]. Per-input preprocessing configurations.
            Keys are input names, values are dicts containing input-specific pipelines.
        @param optional bool. Indicates whether this config is optional. Use the default value defined as a class variable.
        """
        super().__init__(optional)
        self.apply = apply
        self.auto_convert_format = auto_convert_format
        self.pipeline = pipeline
        self.input_configs = input_configs
        self.check_valid(except_list=["optional", "pipeline", "input_configs"])
 
    @classmethod
    def default_config(cls):
        return cls(**cls.DEFAULTS, optional=cls.optional)
 
    @classmethod
    def from_dict(cls, config_dict: dict):
        """Create PreprocessingConfig from dictionary (JSON structure)"""
        params = cls.DEFAULTS.copy()
 
        if "apply" in config_dict:
            params["apply"] = config_dict["apply"]
        if "autoConvertFormat" in config_dict:
            params["auto_convert_format"] = config_dict["autoConvertFormat"]
        if "pipeline" in config_dict:
            params["pipeline"] = config_dict["pipeline"]
        if "inputConfigs" in config_dict:
            params["input_configs"] = config_dict["inputConfigs"]
 
        return cls(**params)
 
    def to_dict(self):
        return {
            "apply": self.apply,
            "autoConvertFormat": self.auto_convert_format,
            "pipeline": self.pipeline,
            "inputConfigs": self.input_configs,
        }
 
 
def get_preprocessing_config(**kwargs) -> PreprocessingConfig:
    """
    @brief Create PreprocessingConfig with partial parameters merged with defaults.
    """
    params = PreprocessingConfig.DEFAULTS.copy()
    params.update(kwargs)
    return PreprocessingConfig(**params, optional=PreprocessingConfig.optional)
 
 
class InputProcessConfig(ConfigABC):
    """
    @brief Unified configuration for input processing.
 
    @details Combines uint8 input handling, image channel configuration, and
    preprocessing pipeline settings into a single configuration object.
    """
 
    optional = True
    DEFAULTS = {
        "uint8_input": None,  # Will use Uint8InputConfig.default_config()
        "image_channels": 0,
        "preprocessing": None,  # Will use PreprocessingConfig.default_config()
    }
 
    py_to_cpp_name = {
        "image_channels": "imageChannels",
    }
 
    min_max_check = {}
 
    @typechecked
    def __init__(
        self,
        uint8_input: Optional[Uint8InputConfig],
        image_channels: int,
        preprocessing: Optional[PreprocessingConfig],
        optional: bool = optional,
    ):
        """
        @brief Initialize the InputProcessConfig.
        @param uint8_input Uint8InputConfig. Configuration for uint8 input handling.
            If None, uses default Uint8InputConfig.
        @param image_channels int. Number of image channels (0=auto, 1=grayscale, 3=RGB, 4=RGBA).
        @param preprocessing PreprocessingConfig. Configuration for input preprocessing pipeline.
            If None, uses default PreprocessingConfig.
        @param optional bool. Indicates whether this config is optional.
        """
        super().__init__(optional)
        self.uint8_input = (
            uint8_input if uint8_input is not None else Uint8InputConfig.default_config()
        )
        self.image_channels = image_channels
        self.preprocessing = (
            preprocessing
            if preprocessing is not None
            else PreprocessingConfig.default_config()
        )
        self.check_valid(
            except_list=["optional", "uint8_input", "preprocessing"]
        )
 
    @classmethod
    def default_config(cls):
        return cls(
            uint8_input=Uint8InputConfig.default_config(),
            image_channels=0,
            preprocessing=PreprocessingConfig.default_config(),
            optional=cls.optional,
        )
 
    @classmethod
    def from_dict(cls, config_dict: dict):
        """Create InputProcessConfig from dictionary (JSON structure)"""
        uint8_input = Uint8InputConfig.from_dict(config_dict.get("uint8Input", {}))
        image_channels = config_dict.get("imageChannels", 0)
        preprocessing = PreprocessingConfig.from_dict(
            config_dict.get("preprocessing", {})
        )
 
        return cls(
            uint8_input=uint8_input,
            image_channels=image_channels,
            preprocessing=preprocessing,
        )
 
    def to_dict(self):
        return {
            "uint8Input": self.uint8_input.to_dict(),
            "imageChannels": self.image_channels,
            "preprocessing": self.preprocessing.to_dict(),
        }
 
 
def get_input_process_config(
    uint8_input_config: Optional[Uint8InputConfig] = None,
    image_channels: int = 0,
    preprocessing_config: Optional[PreprocessingConfig] = None,
) -> InputProcessConfig:
    """
    @brief Create InputProcessConfig with partial parameters merged with defaults.
 
    @param uint8_input_config Uint8InputConfig. Configuration for uint8 input handling.
    @param image_channels int. Number of image channels (0=auto, 1=grayscale, 3=RGB, 4=RGBA).
    @param preprocessing_config PreprocessingConfig. Configuration for input preprocessing pipeline.
    @return InputProcessConfig. The configured input process configuration.
    """
    return InputProcessConfig(
        uint8_input=uint8_input_config,
        image_channels=image_channels,
        preprocessing=preprocessing_config,
        optional=InputProcessConfig.optional,
    )
 
 
# @}