auto-trainer-core 2.0.1.dev353__py3-none-any.whl

autotrainer/core/configuration/behavior_configuration.py

@@ -0,0 +1,323 @@
+import dataclasses
+import enum
+from dataclasses import dataclass, field
+from typing import Type, Optional, Dict
+from typing_extensions import Self
+
+import yaml
+
+from autotrainer.core.logging import get_verbose_logger
+from .animal_presence_configuration import GlobalAnimalPresenceConfig
+from .external_doors_monitor_configuration import ExternalDoorsMonitorConfig
+from .presence_detection_configuration import PresenceDetectionConfig
+from .system_fault_config import SystemFaultConfig
+from .system_maintenance_config import SystemMaintenanceConfig
+from .. import build_kwargs_apply_mapping, make_camelize_representer, make_decamelize_constructor, Offset3DTuple
+
+from ..analysis import HeadbarPressureConfiguration
+from .load_cell_config import LoadCellConfiguration, LoadCellAutoTareConfiguration
+from ..analysis.audio_spectrum_monitor import AudioSpectrumThrashMonitorConfig
+from .alarm_configuration import EmergencyAlarmConfiguration
+from ..analysis.auto_tunnel_fan_monitor import AutoTunnelSweepConfiguration
+
+logger = get_verbose_logger(__name__)
+
+
+@dataclasses.dataclass
+class ShiftXYZTarget:
+
+    # should be in Diamond coordinate system
+    x: float = 1.5
+    y: float = -3
+    z: float = 1
+
+
+def default_shift_xyz_target() -> Offset3DTuple:
+    return Offset3DTuple(**dataclasses.asdict(ShiftXYZTarget()))
+
+
+def default_tongue_eaten_shift() -> Offset3DTuple:
+    return Offset3DTuple(0, 0.5, 0)
+
+
+@dataclasses.dataclass
+class _ShiftXYZBufferHandlerConfig:
+
+    minimum_reach_fail: int = 10  # minimum nbr of failed reach, to make the mean/an entire processing of them
+    target: Offset3DTuple = field(default_factory=default_shift_xyz_target)
+
+
+@dataclasses.dataclass
+class ShiftXYZBufferHandlerConfig(_ShiftXYZBufferHandlerConfig):
+
+    def __init__(self, **kwargs):
+        for c in "xyz":
+            kwargs.pop(f"target_{c}", None)  # old config
+        super().__init__(**kwargs)
+
+
+@dataclasses.dataclass
+class ShiftXYZHandlerConfig:
+
+    use_tongue_eaten: bool = True
+    tongue_eaten_shift: Offset3DTuple = field(default_factory=default_tongue_eaten_shift)
+
+    use_reach_buffer: bool = True
+    selected: str = "ShiftXYZBufferHandler"
+    buffer: ShiftXYZBufferHandlerConfig = field(default_factory=ShiftXYZBufferHandlerConfig)
+
+
+@dataclass
+class AutoCloseGateOnIntersessionConfiguration:
+
+    enabled: bool = False  # enabled/disabled
+    session_min_duration: float = 5  # do not try close gate if session duration shorter than this
+    delay_after_cage_enter: float = 2.5  # only close gate once this delay since cage enter has elapsed
+
+
+@dataclass
+class HomeOnExcessiveDriftDistanceConfiguration:
+    """Execute, when in monitoring (should equal to be in deliver position), home to reset motors if measured drift distance is higher than threshold"""
+
+    enabled: bool = False
+    excessive_distance_threshold: float = 5  # mm
+
+    min_samples: int = 30
+    # only considerate if/when nbr of samples is greater than this.
+    # This can compensate small unsync between inference results and motor status positions,
+    # when the start of the sampling would be done right after the pellet-arm finished moving.
+    # The current inference is giving us ~15 datapoints per second,
+    # and almost same for the motor status position: ~10 / sec.
+    # So this requires/takes ~2 seconds of duration to get what's necessary.
+
+
+@dataclass
+class PelletUncoverConfiguration:
+    min_y_dcs: float = 0  # mm,  minimum Y dcs for all hand parts to be "valid" for uncover
+    trigger_delay: float = 1  # seconds, duration before real active/trigger to uncover when it's "valid"
+
+
+@dataclass
+class PelletDeliveryConfiguration:
+    """
+    Behavior model options related to pellet delivery.
+    """
+
+    is_enabled: bool = False
+    """When disabled not automatic behavior movement will be peformed, but eventually on application start"""
+
+    is_pellet_cover_enabled: bool = False
+    """If enabled: cover pellet when session starts, and wait uncover condition"""
+
+    # not really related to pellet delivery but has been here since start:
+    is_intersession_analysis_enabled: bool = False
+    is_intersession_pellet_shift_enabled: bool = True
+
+    max_pellets_per_session: int = 10  # actually unused
+    max_pellets_per_day: int = 50  # actually unused
+    max_pellet_missing_seconds: float = 1.0  # how long to wait before load pellet when pellet missing/not seen
+    # this help ensure we don't execute a load pellet if we get an incorrect pose_result with pellet seen == False,
+    # which can happen eventually (missed inference detection basically).
+
+    auto_correct_motors_drift: bool = False  # attempt "live" motor drift correction -- DISABLED in code
+
+    use_triangle_pellet_distance_too_far: bool = False
+    """If enabled then a triangle-pellet too far distance also trigger a load-pellet"""
+    triangle_pellet_expected_distance: float = 5  # mm
+    triangle_pellet_diff_too_far_threshold: float = 1  # mm
+
+    @classmethod
+    def from_version_zero(cls, content: dict) -> Self:
+        return cls(**build_kwargs_apply_mapping(content, (
+            *(f.name for f in dataclasses.fields(cls)),
+            ('is_enabled', 'is_deliver_pellet_enabled'),
+            ('is_pellet_cover_enabled', 'is_cover_pellet_enabled'),
+        ), skip_remaining=True))
+
+
+class HeadClampReleaseMode(str, enum.Enum):
+    ACTIVITY = "Activity"
+    FIXED_DURATION = "Fixed duration"
+
+
+@dataclass
+class HeadClampConfiguration:
+    """
+    Behavior model options related to the head clamp magnet including standard intensity and auto-clamp actions.
+    """
+
+    baseline_intensity: float = 0.0
+    auto_clamp_intensity: float = 100.0
+    auto_clamp_release_tone_freq: int = 7000
+    auto_clamp_release_tone_delay: float = 0.1
+    before_reengage_delay: float = 5  # how long to wait/delay before allow/execute a re-engage after a disengage.
+
+    prerelease_intensity: float = 70  # absolute % value
+    prerelease_duration: float = 0  # seconds, if 0 then this pre-release is disabled / does not occur.
+
+    release_mode: str = HeadClampReleaseMode.ACTIVITY.value
+
+    # HeadClampReleaseMode.ACTIVITY
+    auto_clamp_no_activity_release_delay: float = 30  # seconds
+    auto_clamp_release_load_count: int = 100_000
+
+    # HeadClampReleaseMode.FIXED_DURATION
+    fixed_duration_release_delay: float = 30  # seconds
+
+
+    @classmethod
+    def from_version_zero(cls, content: dict) -> Self:
+        return cls(**build_kwargs_apply_mapping(
+            content,
+            tuple(f.name for f in dataclasses.fields(cls)),
+            skip_remaining=True,
+        ))
+
+
+@dataclasses.dataclass
+class AutoEndSessionConfiguration:
+    # enabled: bool = True
+
+    no_activity_delay_minutes: int = 1
+    """This is only for the Nose part. If it's not seen that much duration consecutively, 
+     then also auto-end session"""
+
+    animal_tunnel_no_activity_delay: float = 10  # seconds
+    """Delay without tunnel animal activity (== any animal part seen *and* low load-cell variance)
+     which triggers auto-end session"""
+
+
+@dataclasses.dataclass
+class BatchSessionRecordingConfiguration:
+
+    enabled: bool = False
+
+    maximum_batch_size: int = 0
+    """If 0: no max batch size, otherwise, once batch is over the size: force batch session processing"""
+
+
+@dataclass
+class _BehaviorConfiguration:
+    pellet_delivery: PelletDeliveryConfiguration = field(default_factory=PelletDeliveryConfiguration)
+    pellet_uncover: PelletUncoverConfiguration = field(default_factory=PelletUncoverConfiguration)
+    shift_xyz_handler: ShiftXYZHandlerConfig = field(default_factory=ShiftXYZHandlerConfig)
+    head_clamp: HeadClampConfiguration = field(default_factory=HeadClampConfiguration)
+    load_cell: LoadCellConfiguration = field(default_factory=LoadCellConfiguration)
+    headbar_pressure: HeadbarPressureConfiguration = field(default_factory=HeadbarPressureConfiguration)
+    auto_tare: LoadCellAutoTareConfiguration = field(default_factory=LoadCellAutoTareConfiguration)
+    audio: AudioSpectrumThrashMonitorConfig = field(default_factory=AudioSpectrumThrashMonitorConfig)
+    global_animal_presence: GlobalAnimalPresenceConfig = field(default_factory=GlobalAnimalPresenceConfig)
+    emergency_alarm: EmergencyAlarmConfiguration = field(default_factory=EmergencyAlarmConfiguration)
+    external_doors: ExternalDoorsMonitorConfig = field(default_factory=ExternalDoorsMonitorConfig)
+    topcam_presence_detection: PresenceDetectionConfig = field(default_factory=PresenceDetectionConfig)
+    auto_end_session: AutoEndSessionConfiguration = field(default_factory=AutoEndSessionConfiguration)
+    auto_tunnel_sweep: AutoTunnelSweepConfiguration = field(default_factory=AutoTunnelSweepConfiguration)
+    batch_session_recording: BatchSessionRecordingConfiguration = field(default_factory=BatchSessionRecordingConfiguration)
+    auto_close_gate_on_intersession: AutoCloseGateOnIntersessionConfiguration = field(default_factory=AutoCloseGateOnIntersessionConfiguration)
+    home_on_excessive_drift_distance: HomeOnExcessiveDriftDistanceConfiguration = field(default_factory=HomeOnExcessiveDriftDistanceConfiguration)
+    system_maintenance: SystemMaintenanceConfig = field(default_factory=SystemMaintenanceConfig)
+    system_fault: SystemFaultConfig = field(default_factory=SystemFaultConfig)
+
+    @classmethod
+    def from_version_zero(cls, content: Dict) -> Self:
+        configuration = cls()
+
+        if "head_fix" in content:
+            if "load_cell" in content["head_fix"]:
+                configuration.load_cell = LoadCellConfiguration.from_version_zero(content["head_fix"]["load_cell"])
+            if "headbar_pressure" in content["head_fix"]:
+                configuration.headbar_pressure = HeadbarPressureConfiguration.from_version_zero(
+                    content["head_fix"]["headbar_pressure"]
+                )
+            if "auto_tare" in content["head_fix"]:
+                configuration.auto_tare = LoadCellAutoTareConfiguration.from_version_zero(
+                    content["head_fix"]["auto_tare"])
+
+        if "behavior" in content:
+            configuration.head_clamp = HeadClampConfiguration.from_version_zero(content["behavior"])
+            configuration.pellet_delivery = PelletDeliveryConfiguration.from_version_zero(content["behavior"])
+
+        return configuration
+
+    @classmethod
+    def from_version_one(cls, content: Dict):
+        headclamp = content.get("head_clamp", {})
+        headclamp.pop('max_baseline_intensity')
+        headclamp.pop('baseline_intensity_increment')
+        baseline = headclamp.pop('min_baseline_intensity')
+        if baseline is not None:
+            headclamp['baseline_intensity'] = baseline
+        return cls(
+            load_cell=LoadCellConfiguration.from_version_one(content.get("load_cell", {})),
+            headbar_pressure=HeadbarPressureConfiguration(**content.get("headbar_pressure", {})),
+            auto_tare=LoadCellAutoTareConfiguration(**content.get("auto_tare", {})),
+            head_clamp=HeadClampConfiguration(**headclamp),
+            pellet_delivery=PelletDeliveryConfiguration(**content.get("pellet_delivery", {})),
+        )
+
+
+@dataclasses.dataclass
+class BehaviorConfiguration(_BehaviorConfiguration):
+    # NB: having to subclass _BehaviorConfiguration dataclass type to allow to customize init signature (and body):
+
+    def __init__(self,
+                 *,
+                 mouse_presence=None,  # temporarily to be back-compatible with previous
+                 **kwargs):
+        if mouse_presence is not None:
+            logger.notice("Dropping previous mouse_presence config, new default one will be used. dropped entry: %s",
+                          mouse_presence)
+        super().__init__(**kwargs)
+
+
+_cls_2_tag = {
+    PelletDeliveryConfiguration: "PelletDeliveryConfiguration",
+    PelletUncoverConfiguration: "PelletUncoverConfiguration",
+    LoadCellConfiguration: "LoadCellConfiguration",
+    HeadClampConfiguration: "HeadClampConfiguration",
+    HeadbarPressureConfiguration: "HeadbarPressureConfiguration",
+    LoadCellAutoTareConfiguration: "LoadCellAutoTareConfiguration",
+    BehaviorConfiguration: "BehaviorConfiguration",
+    AudioSpectrumThrashMonitorConfig: "AudioMonitorConfiguration",
+    GlobalAnimalPresenceConfig: "AnimalPresenceConfiguration",
+    EmergencyAlarmConfiguration: "EmergencyAlarmConfiguration",
+    PresenceDetectionConfig: "PresenceDetectionConfiguration",
+    ExternalDoorsMonitorConfig: "ExternalDoorsMonitorConfiguration",
+    AutoEndSessionConfiguration: "AutoEndSessionConfiguration",
+    AutoTunnelSweepConfiguration: "AutoTunnelSweepConfiguration",
+    BatchSessionRecordingConfiguration: "BatchSessionRecordingConfiguration",
+    AutoCloseGateOnIntersessionConfiguration: "AutoCloseGateOnIntersessionConfiguration",
+    HomeOnExcessiveDriftDistanceConfiguration: "HomeOnExcessiveDriftDistance",  # missed Configuration suffix
+    # ShiftXYZTarget: "ShiftXYZTarget",  # replaced by Offset3dTuple.
+    ShiftXYZHandlerConfig: "ShiftXYZHandlerConfiguration",
+    ShiftXYZBufferHandlerConfig: "ShiftXYZBufferHandlerConfiguration",
+    SystemMaintenanceConfig: "SystemMaintenanceConfig",
+    SystemFaultConfig: "SystemFaultConfig",
+}
+
+
+def add_behavior_configuration_representers(dumper: Type[yaml.SafeDumper]):
+    def add(klass, tagname):
+        dumper.add_representer(klass, make_camelize_representer(f"!{tagname}"))
+
+    for cls, tag in _cls_2_tag.items():
+        add(cls, tag)
+
+    from autotrainer.core.configuration import repr_offset3d_tuple
+
+    dumper.add_representer(ShiftXYZTarget, repr_offset3d_tuple)
+    # changed to use Offset3dTuple
+
+
+def add_behavior_configuration_constructors(safe_loader: Type[yaml.SafeLoader]):
+
+    def add(klass, tagname):
+        safe_loader.add_constructor(f"!{tagname}", make_decamelize_constructor(klass))
+
+    for cls, tag in _cls_2_tag.items():
+        add(cls, tag)
+
+    add(GlobalAnimalPresenceConfig, "MousePresenceConfiguration")
+    # keeping temporarily MousePresenceConfiguration, was renamed to AnimalPresenceConfiguration. Back-compatibility.
+    # todo: remove some when later.
+    #

autotrainer/core/configuration/camera_configuration.py

@@ -0,0 +1,108 @@
+import re
+import urllib.parse
+from dataclasses import dataclass, field
+from enum import Enum, IntEnum
+from typing import Dict, Any
+
+from typing_extensions import Self
+
+import yaml
+
+from autotrainer.core.logging import get_verbose_logger
+from autotrainer.core import make_camelize_representer, make_decamelize_constructor
+from autotrainer.core.configuration import SystemConfigurationDumper
+
+
+logger = get_verbose_logger(__name__)
+
+
+class CameraId(IntEnum):
+    Left = 0
+    Right = 1
+    Web = 2
+
+    def __str__(self) -> str:
+        # Used as part of video file and related naming conventions.
+        if self == CameraId.Left:
+            return "left"
+        elif self == CameraId.Right:
+            return "right"
+        elif self == CameraId.Web:
+            return "web"
+        else:
+            raise ValueError(f"Invalid camera id: {self}")
+
+
+@dataclass
+class CameraConfiguration:
+    id: CameraId = CameraId.Left
+    name: str = "(unnamed)"
+    is_enabled: bool = False
+    is_record_enabled: bool = False
+    record_mode: int = 0
+    record_prebuffer_duration: float = 1  # seconds, delay of pre-buffer to use/record when start-recording is executed
+    is_still_image_capture_enabled: bool = False
+    still_image_capture_interval: float = 5.0
+    scheme: str = ""
+    host: str = ""
+    port: int = 0
+    path: str = ""
+    params: Dict[str, Any] = field(default_factory=dict)
+
+    def __post_init__(self):
+        if not isinstance(self.id, CameraId):
+            self.id = CameraId(self.id)
+        if "%" in self.path:
+            # this could possibly be removed later when ~all present config files would be already fixed.
+            self.path = urllib.parse.unquote(self.path)
+            logger.info("Replaced %%-encoded path from configuration with unquoted one: %r", self.path)
+        self.path = re.sub(r"/+", "/", self.path)  # sanitize
+
+    @classmethod
+    def from_version_zero(cls, name: str, content: dict) -> Self:
+        if name == "camera1":
+            camera_id = CameraId.Left
+        elif name == "camera2":
+            camera_id = CameraId.Right
+        else:
+            camera_id = CameraId.Web
+
+        if "camera" in content:
+            camera = content["camera"]
+        else:
+            return None
+
+        known_params = ["scheme", "host", "path", "port"]
+
+        params = dict()
+
+        for key in camera:
+            if key not in known_params:
+                params[key] = camera[key]
+
+        return cls(
+            id=camera_id,
+            name=content.get("name", "(unnamed)"),
+            is_enabled=content.get("is_enabled", False),
+            is_record_enabled=content.get("is_record_enabled", False),
+            record_mode=content.get("record_mode", 0),
+            is_still_image_capture_enabled=content.get("is_still_image_capture_enabled", False),
+            still_image_capture_interval=content.get("still_image_capture_interval", 0.0),
+            scheme=camera.get("scheme", ""),
+            host=camera.get("host", ""),
+            port=camera.get("port", 0),
+            path=camera.get("path", ""),
+            params=params
+        )
+
+
+camera_configuration_representer = make_camelize_representer("!CameraConfiguration")
+
+
+def camera_id_representer(dumper: yaml.SafeDumper, obj):
+    return dumper.represent_data(int(obj))
+
+SystemConfigurationDumper.add_representer(CameraId, camera_id_representer)
+
+
+camera_configuration_constructor = make_decamelize_constructor(CameraConfiguration)

autotrainer/core/configuration/external_doors_monitor_configuration.py

@@ -0,0 +1,9 @@
+
+
+import dataclasses
+
+
+@dataclasses.dataclass
+class ExternalDoorsMonitorConfig:
+
+    trigger_open_delay: float = 3

autotrainer/core/configuration/hardware_configuration.py

@@ -0,0 +1,30 @@
+from dataclasses import dataclass
+
+from typing import Optional
+from typing_extensions import Self
+
+
+from autotrainer.core import make_camelize_representer, make_decamelize_constructor
+
+
+@dataclass
+class HardwareConfiguration:
+    tunnel_identifier: str = ""
+    pellet_identifier: str = ""
+
+    min_ack_timeout: Optional[float] = None  # min device-ack-timeout
+
+    @classmethod
+    def from_version_zero(cls, content: dict) -> Self:
+        configuration = cls()
+
+        if "head_fix" in content:
+            configuration.tunnel_identifier = content["head_fix"].get("port", "")
+        if "pellet_delivery" in content:
+            configuration.pellet_identifier = content["pellet_delivery"].get("port", "")
+
+        return configuration
+
+
+hardware_configuration_representer = make_camelize_representer("!HardwareConfiguration")
+hardware_configuration_constructor = make_decamelize_constructor(HardwareConfiguration)

autotrainer/core/configuration/inference_configuration.py

@@ -0,0 +1,26 @@
+from dataclasses import dataclass
+
+from typing_extensions import Self
+
+from autotrainer.core import build_kwargs_apply_mapping, make_camelize_representer, make_decamelize_constructor
+
+
+@dataclass
+class InferenceConfiguration:
+    pose_model_location: str = ""
+    is_enabled: bool = False
+    intersession_wait_time: float = 2.0
+    """
+    The amount of time to wait for the video files to be available for processing.  This is more of a system property
+    than an algorithm/behavior property.
+    """
+
+    @classmethod
+    def from_version_zero(cls, content: dict) -> Self:
+        return cls(**build_kwargs_apply_mapping(content, (
+            ('pose_model_location', 'model'),
+        )))
+
+
+inference_configuration_representer = make_camelize_representer("!InferenceConfiguration")
+inference_configuration_constructor = make_decamelize_constructor(InferenceConfiguration)

autotrainer/core/configuration/load_cell_config.py

@@ -0,0 +1,61 @@
+from dataclasses import dataclass
+from typing import Dict, Any
+from typing_extensions import Self
+
+from autotrainer.core import build_kwargs_apply_mapping
+
+
+@dataclass
+class LoadCellConfiguration:
+    # NB: this is the current/previous value used on agx001:
+    weight_active_threshold: float = 2  # grams ; if above then will become engaged if above for threshold_duration
+    weight_inactive_threshold: float = 2  # grams ;
+    # if below then will become disengaged if below for more than
+
+    threshold_duration: float = 0.25
+    # duration threshold for engaged or thrashing_detected, must remain during that delay to make the change
+
+    min_event_duration: float = 5.0
+    min_post_event_hold_duration: float = 2.0
+    # delay before inactive if was engaged/active for more than min_event_duration
+
+    thrashing_var_weight_threshold_min: float = 20  # grams
+    thrashing_var_weight_threshold_max: float = 30  # grams
+    thrashing_var_min_delay: float = 0.05  # seconds
+    thrashing_var_max_delay: float = 0.2  # seconds
+    thrashing_min_ptp_change_count: int = 3  # nbr of "ptp" change needed in a row during var_max_delay
+
+    # allow to filter out values smaller than min, or larger than max :
+    weight_min_filter: float = -500  # grams
+    weight_max_filter: float = 500  # grams
+
+    @classmethod
+    def from_version_zero(cls, content: Dict[str, Any]) -> Self:
+        return cls(**build_kwargs_apply_mapping(content, (
+            ('weight_active_threshold', 'load_trigger'),
+            ('threshold_duration', 'min_load_on_duration'),
+            ('min_post_event_hold_duration', 'min_load_off_duration'),
+        )))
+
+    @classmethod
+    def from_version_one(cls, content: Dict[str, Any]) -> Self:
+        return cls(**build_kwargs_apply_mapping(content, (
+            ('weight_active_threshold', 'threshold'),
+        )))
+
+
+@dataclass
+class LoadCellAutoTareConfiguration:
+    threshold: float = 0.1
+    range_threshold: float = 0.75
+    duration: float = 2.0
+    sample_rate: int = 100
+
+    @classmethod
+    def from_version_zero(cls, content: dict) -> Self:
+        kwargs = {}
+        for k in {"threshold", "range_threshold", "duration", "sample_rate"}:
+            val = content.get(k)
+            if val is not None:
+                kwargs[k] = val
+        return cls(**kwargs)

autotrainer/core/configuration/persistence_configuration.py

@@ -0,0 +1,29 @@
+from dataclasses import dataclass
+from typing import ClassVar
+
+from typing_extensions import Self
+from pathlib import Path
+
+from autotrainer.core import make_camelize_representer, make_decamelize_constructor
+
+
+@dataclass
+class PersistenceConfiguration:
+
+    DEFAULT_OUTPUT_PATH: ClassVar[Path] = Path("~/Documents/RawDataLocal")  # must use .expanduser() on it
+
+    output_location: str = DEFAULT_OUTPUT_PATH.expanduser().as_posix()
+
+    @classmethod
+    def get_default_output_path(cls) -> Path:
+        return cls.DEFAULT_OUTPUT_PATH.expanduser()
+
+    @classmethod
+    def from_version_zero(cls, content: dict) -> Self:
+        return cls(
+            output_location=content.get("output_location", "")
+        )
+
+
+persistence_configuration_representer = make_camelize_representer("!PersistenceConfiguration")
+persistence_configuration_constructor = make_decamelize_constructor(PersistenceConfiguration)

autotrainer/core/configuration/presence_detection_configuration.py

@@ -0,0 +1,9 @@
+import dataclasses
+
+
+@dataclasses.dataclass
+class PresenceDetectionConfig:
+    pc_threshold: float = 2.2  # percent  -  lower makes more sensible to noise
+    pc_high_exclude_threshold: float = 85  # percent ; this is to exclude too big % diff due to switch light ON/OFF.
+    mask_lower_zero: int = 8 # gray value. this is "smooth" the difference, to be less sensible to noise. from 0 -> 255
+    max_delay_skip_threshold: float = 0.5  # seconds, how much to keep/look at diff over previous frames