euler-preprocess 3.2.0__tar.gz → 3.3.0__tar.gz

{euler_preprocess-3.2.0/euler_preprocess.egg-info → euler_preprocess-3.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: euler-preprocess
-Version: 3.2.0
+Version: 3.3.0
 Summary: Physics-based preprocessing (fog, etc.) for RGB+depth datasets
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
@@ -323,6 +323,28 @@ noise is fine-grained rather than blocky. `black_noise_floor` with
 noise in near-clipped black regions, so the strongest visible noise sits in
 dim-but-readable shadows.
 
+Set `sensor.noise_adjustment` for relative, scenario-level noise controls on
+top of the selected camera/condition profile. `level: 1.0` leaves the authored
+profile unchanged; lower values suppress read/static/chroma noise and higher
+values amplify it. `static_chroma_bias` ranges from `-1.0` for more fixed
+pattern, row/column, banding, and bad-pixel noise to `1.0` for more
+chromatic/high-ISO-looking shadow noise:
+
+```json
+{
+  "capture_overrides": {
+    "sensor": {
+      "condition_profile": "nominal_gloom",
+      "noise_adjustment": {
+        "enabled": true,
+        "level": 1.25,
+        "static_chroma_bias": 0.35
+      }
+    }
+  }
+}
+```
+
 Any stage can define `condition_profiles` to sample coherent per-image settings
 before the stage runs. This is useful for exposure states where ISO, exposure
 gain, read noise, banding, and dark/fog noise modulation should move together:

euler_preprocess-3.2.0/PKG-INFO → euler_preprocess-3.3.0/README.md

@@ -1,17 +1,3 @@
-Metadata-Version: 2.4
-Name: euler-preprocess
-Version: 3.2.0
-Summary: Physics-based preprocessing (fog, etc.) for RGB+depth datasets
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-Requires-Dist: numpy
-Requires-Dist: Pillow
-Requires-Dist: euler-loading
-Provides-Extra: gpu
-Requires-Dist: torch; extra == "gpu"
-Provides-Extra: progress
-Requires-Dist: tqdm; extra == "progress"
-
 # euler-preprocess
 
 Physics-based preprocessing transforms for multi-modal RGB+depth datasets. Built on top of [euler-loading](https://github.com/d-rothen/euler-loading) and [ds-crawler](https://github.com/d-rothen/ds-crawler).
@@ -323,6 +309,28 @@ noise is fine-grained rather than blocky. `black_noise_floor` with
 noise in near-clipped black regions, so the strongest visible noise sits in
 dim-but-readable shadows.
 
+Set `sensor.noise_adjustment` for relative, scenario-level noise controls on
+top of the selected camera/condition profile. `level: 1.0` leaves the authored
+profile unchanged; lower values suppress read/static/chroma noise and higher
+values amplify it. `static_chroma_bias` ranges from `-1.0` for more fixed
+pattern, row/column, banding, and bad-pixel noise to `1.0` for more
+chromatic/high-ISO-looking shadow noise:
+
+```json
+{
+  "capture_overrides": {
+    "sensor": {
+      "condition_profile": "nominal_gloom",
+      "noise_adjustment": {
+        "enabled": true,
+        "level": 1.25,
+        "static_chroma_bias": 0.35
+      }
+    }
+  }
+}
+```
+
 Any stage can define `condition_profiles` to sample coherent per-image settings
 before the stage runs. This is useful for exposure states where ISO, exposure
 gain, read noise, banding, and dark/fog noise modulation should move together:

{euler_preprocess-3.2.0 → euler_preprocess-3.3.0}/euler_preprocess/fog/capture.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from copy import deepcopy
 import io
 import math
 from dataclasses import dataclass, field
@@ -522,6 +523,7 @@ class SensorStage(ConfiguredCaptureStage):
             rng,
             manual_exposure_gain=exposure,
         )
+        config = _apply_sensor_noise_adjustment(config, rng)
         wb = _sample_triplet(config.get("white_balance", [1.0, 1.0, 1.0]), rng)
         wb_jitter = _sample_float(config, "white_balance_jitter", 0.0, rng)
         if wb_jitter > 0.0:
@@ -717,6 +719,7 @@ class SensorStage(ConfiguredCaptureStage):
             rng,
             manual_exposure_gain=exposure,
         )
+        config = _apply_sensor_noise_adjustment(config, rng)
         wb = _sample_triplet(config.get("white_balance", [1.0, 1.0, 1.0]), rng)
         wb_jitter = _sample_float(config, "white_balance_jitter", 0.0, rng)
         if wb_jitter > 0.0:
@@ -2152,6 +2155,338 @@ def _resolve_electron_capacity_torch(
     )
 
 
+def _apply_sensor_noise_adjustment(
+    config: Mapping[str, Any],
+    rng: np.random.Generator,
+) -> Mapping[str, Any]:
+    cfg = _config_block(config, "noise_adjustment")
+    if not cfg or not _bool_value(cfg.get("enabled", True)):
+        return config
+
+    level = max(
+        _sample_float_from_keys(
+            cfg,
+            ("level", "amount", "factor", "noise_level"),
+            1.0,
+            rng,
+        ),
+        0.0,
+    )
+    bias = float(
+        np.clip(
+            _sample_float_from_keys(
+                cfg,
+                ("static_chroma_bias", "character_bias", "chroma_bias"),
+                0.0,
+                rng,
+            ),
+            -1.0,
+            1.0,
+        )
+    )
+    groups = _config_block(cfg, "groups")
+    limits = _config_block(cfg, "limits")
+
+    min_factor = max(_sample_float(limits, "min_factor", 0.0, rng), 0.0)
+    max_factor = max(_sample_float(limits, "max_factor", 8.0, rng), min_factor)
+
+    def group_factor(name: str, base: float) -> float:
+        factor = base * max(_sample_float(groups, name, 1.0, rng), 0.0)
+        return float(np.clip(factor, min_factor, max_factor))
+
+    read_factor = group_factor("read", level * math.pow(2.0, 0.35 * bias))
+    static_factor = group_factor("static", level * math.pow(2.0, -bias))
+    banding_factor = group_factor("banding", static_factor)
+    bad_pixel_factor = group_factor("bad_pixels", static_factor)
+    chroma_factor = group_factor("chroma", level * math.pow(2.0, bias))
+    shadow_luma_factor = group_factor("shadow_luma", level)
+    modulation_factor = group_factor("modulation", 1.0 + (level - 1.0) * 0.75)
+
+    if (
+        abs(read_factor - 1.0) < 1e-9
+        and abs(static_factor - 1.0) < 1e-9
+        and abs(banding_factor - 1.0) < 1e-9
+        and abs(bad_pixel_factor - 1.0) < 1e-9
+        and abs(chroma_factor - 1.0) < 1e-9
+        and abs(shadow_luma_factor - 1.0) < 1e-9
+        and abs(modulation_factor - 1.0) < 1e-9
+    ):
+        return config
+
+    adjusted = deepcopy(dict(config))
+
+    _scale_config_path(adjusted, ("read_noise_electrons",), read_factor, min_value=0.0)
+    _scale_config_path(adjusted, ("read_noise_sigma",), read_factor, min_value=0.0)
+
+    _scale_config_path(adjusted, ("fixed_pattern_sigma",), static_factor, min_value=0.0)
+    _scale_config_path(adjusted, ("row_noise_sigma",), banding_factor, min_value=0.0)
+    _scale_config_path(adjusted, ("column_noise_sigma",), banding_factor, min_value=0.0)
+    _scale_config_path(
+        adjusted,
+        ("banding_modulation",),
+        banding_factor,
+        min_value=0.0,
+        max_value=1.0,
+    )
+
+    max_bad_pixel_probability = _sample_float(
+        limits,
+        "max_bad_pixel_probability",
+        0.05,
+        rng,
+    )
+    _scale_config_path(
+        adjusted,
+        ("hot_pixel_probability",),
+        bad_pixel_factor,
+        min_value=0.0,
+        max_value=max_bad_pixel_probability,
+    )
+    _scale_config_path(
+        adjusted,
+        ("dead_pixel_probability",),
+        bad_pixel_factor,
+        min_value=0.0,
+        max_value=max_bad_pixel_probability,
+    )
+
+    for key in ("dark_gain", "depth_gain", "fog_gain"):
+        _scale_config_path(
+            adjusted,
+            ("noise_modulation", key),
+            modulation_factor,
+            min_value=0.0,
+        )
+    _scale_config_path(
+        adjusted,
+        ("noise_modulation", "max_gain"),
+        modulation_factor,
+        anchor=1.0,
+        min_value=1.0,
+    )
+
+    _scale_config_path(
+        adjusted,
+        ("shadow_recovery_noise", "luma_sigma"),
+        shadow_luma_factor,
+        min_value=0.0,
+    )
+    _scale_config_path(
+        adjusted,
+        ("shadow_recovery_noise", "chroma_sigma"),
+        chroma_factor,
+        min_value=0.0,
+    )
+    _scale_config_path(
+        adjusted,
+        ("shadow_recovery_noise", "blotch_sigma"),
+        chroma_factor,
+        min_value=0.0,
+    )
+    _scale_config_path(
+        adjusted,
+        ("shadow_recovery_noise", "red_chroma_gain"),
+        chroma_factor,
+        anchor=1.0,
+        min_value=0.0,
+    )
+    _scale_config_path(
+        adjusted,
+        ("shadow_recovery_noise", "blue_chroma_gain"),
+        chroma_factor,
+        anchor=1.0,
+        min_value=0.0,
+    )
+    _scale_config_path(
+        adjusted,
+        ("shadow_recovery_noise", "chroma_axis_correlation"),
+        chroma_factor,
+        min_value=-0.95,
+        max_value=0.95,
+    )
+    return adjusted
+
+
+def _sample_float_from_keys(
+    config: Mapping[str, Any],
+    keys: tuple[str, ...],
+    default: float,
+    rng: np.random.Generator,
+) -> float:
+    for key in keys:
+        if config.get(key) is not None:
+            return _sample_float(config, key, default, rng)
+    return float(default)
+
+
+def _scale_config_path(
+    config: dict[str, Any],
+    path: tuple[str, ...],
+    factor: float,
+    *,
+    anchor: float = 0.0,
+    min_value: float | None = None,
+    max_value: float | None = None,
+) -> None:
+    parent: dict[str, Any] = config
+    for key in path[:-1]:
+        value = parent.get(key)
+        if not isinstance(value, dict):
+            return
+        parent = value
+    key = path[-1]
+    if key not in parent or parent[key] is None:
+        return
+    parent[key] = _scale_numeric_spec(
+        parent[key],
+        factor,
+        anchor=anchor,
+        min_value=min_value,
+        max_value=max_value,
+    )
+
+
+def _scale_numeric_spec(
+    spec: Any,
+    factor: float,
+    *,
+    anchor: float = 0.0,
+    min_value: float | None = None,
+    max_value: float | None = None,
+) -> Any:
+    if isinstance(spec, bool) or spec is None:
+        return spec
+    if isinstance(spec, (int, float)):
+        return _clamp_scaled_number(
+            anchor + (float(spec) - anchor) * factor,
+            min_value,
+            max_value,
+        )
+    if isinstance(spec, list):
+        return [
+            _scale_numeric_spec(
+                value,
+                factor,
+                anchor=anchor,
+                min_value=min_value,
+                max_value=max_value,
+            )
+            for value in spec
+        ]
+    if isinstance(spec, tuple):
+        return tuple(
+            _scale_numeric_spec(
+                value,
+                factor,
+                anchor=anchor,
+                min_value=min_value,
+                max_value=max_value,
+            )
+            for value in spec
+        )
+    if not isinstance(spec, dict):
+        return spec
+
+    scaled = dict(spec)
+    dist = scaled.get("dist")
+    if dist is None:
+        if "value" in scaled:
+            scaled["value"] = _scale_numeric_spec(
+                scaled["value"],
+                factor,
+                anchor=anchor,
+                min_value=min_value,
+                max_value=max_value,
+            )
+        return scaled
+
+    if dist == "constant":
+        scaled["value"] = _scale_numeric_spec(
+            scaled.get("value", 0.0),
+            factor,
+            anchor=anchor,
+            min_value=min_value,
+            max_value=max_value,
+        )
+    elif dist == "uniform":
+        scaled["min"] = _scale_numeric_spec(
+            scaled["min"],
+            factor,
+            anchor=anchor,
+            min_value=min_value,
+            max_value=max_value,
+        )
+        scaled["max"] = _scale_numeric_spec(
+            scaled["max"],
+            factor,
+            anchor=anchor,
+            min_value=min_value,
+            max_value=max_value,
+        )
+        if scaled["min"] > scaled["max"]:
+            scaled["min"], scaled["max"] = scaled["max"], scaled["min"]
+    elif dist == "normal":
+        scaled["mean"] = _scale_numeric_spec(
+            scaled["mean"],
+            factor,
+            anchor=anchor,
+            min_value=min_value,
+            max_value=max_value,
+        )
+        scaled["std"] = max(float(scaled.get("std", 0.0)) * abs(factor), 0.0)
+        for key in ("min", "max"):
+            if key in scaled and scaled[key] is not None:
+                scaled[key] = _scale_numeric_spec(
+                    scaled[key],
+                    factor,
+                    anchor=anchor,
+                    min_value=min_value,
+                    max_value=max_value,
+                )
+        if scaled.get("min") is not None and scaled.get("max") is not None:
+            if scaled["min"] > scaled["max"]:
+                scaled["min"], scaled["max"] = scaled["max"], scaled["min"]
+    elif dist == "lognormal":
+        if anchor == 0.0 and factor > 0.0:
+            scaled["mean"] = float(scaled.get("mean", 0.0)) + math.log(factor)
+        for key in ("min", "max"):
+            if key in scaled and scaled[key] is not None:
+                scaled[key] = _scale_numeric_spec(
+                    scaled[key],
+                    factor,
+                    anchor=anchor,
+                    min_value=min_value,
+                    max_value=max_value,
+                )
+        if scaled.get("min") is not None and scaled.get("max") is not None:
+            if scaled["min"] > scaled["max"]:
+                scaled["min"], scaled["max"] = scaled["max"], scaled["min"]
+    elif dist == "choice":
+        scaled["values"] = [
+            _scale_numeric_spec(
+                value,
+                factor,
+                anchor=anchor,
+                min_value=min_value,
+                max_value=max_value,
+            )
+            for value in scaled.get("values", [])
+        ]
+    return scaled
+
+
+def _clamp_scaled_number(
+    value: float,
+    min_value: float | None,
+    max_value: float | None,
+) -> float:
+    if min_value is not None:
+        value = max(float(min_value), value)
+    if max_value is not None:
+        value = min(float(max_value), value)
+    return float(value)
+
+
 def _sensor_noise_modulation(
     signal: np.ndarray,
     context: CaptureContext,

euler_preprocess-3.2.0/README.md → euler_preprocess-3.3.0/euler_preprocess.egg-info/PKG-INFO

@@ -1,3 +1,17 @@
+Metadata-Version: 2.4
+Name: euler-preprocess
+Version: 3.3.0
+Summary: Physics-based preprocessing (fog, etc.) for RGB+depth datasets
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: Pillow
+Requires-Dist: euler-loading
+Provides-Extra: gpu
+Requires-Dist: torch; extra == "gpu"
+Provides-Extra: progress
+Requires-Dist: tqdm; extra == "progress"
+
 # euler-preprocess
 
 Physics-based preprocessing transforms for multi-modal RGB+depth datasets. Built on top of [euler-loading](https://github.com/d-rothen/euler-loading) and [ds-crawler](https://github.com/d-rothen/ds-crawler).
@@ -309,6 +323,28 @@ noise is fine-grained rather than blocky. `black_noise_floor` with
 noise in near-clipped black regions, so the strongest visible noise sits in
 dim-but-readable shadows.
 
+Set `sensor.noise_adjustment` for relative, scenario-level noise controls on
+top of the selected camera/condition profile. `level: 1.0` leaves the authored
+profile unchanged; lower values suppress read/static/chroma noise and higher
+values amplify it. `static_chroma_bias` ranges from `-1.0` for more fixed
+pattern, row/column, banding, and bad-pixel noise to `1.0` for more
+chromatic/high-ISO-looking shadow noise:
+
+```json
+{
+  "capture_overrides": {
+    "sensor": {
+      "condition_profile": "nominal_gloom",
+      "noise_adjustment": {
+        "enabled": true,
+        "level": 1.25,
+        "static_chroma_bias": 0.35
+      }
+    }
+  }
+}
+```
+
 Any stage can define `condition_profiles` to sample coherent per-image settings
 before the stage runs. This is useful for exposure states where ISO, exposure
 gain, read noise, banding, and dark/fog noise modulation should move together:

{euler_preprocess-3.2.0 → euler_preprocess-3.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "euler-preprocess"
-version = "3.2.0"
+version = "3.3.0"
 description = "Physics-based preprocessing (fog, etc.) for RGB+depth datasets"
 readme = "README.md"
 requires-python = ">=3.9"

{euler_preprocess-3.2.0 → euler_preprocess-3.3.0}/tests/test_fog_aux_outputs.py

@@ -1652,6 +1652,95 @@ def _deterministic_sensor_pipeline(
     )
 
 
+def test_sensor_noise_adjustment_scales_authored_noise_groups() -> None:
+    config = {
+        "read_noise_sigma": {"dist": "uniform", "min": 0.01, "max": 0.02},
+        "fixed_pattern_sigma": 0.001,
+        "row_noise_sigma": 0.002,
+        "column_noise_sigma": 0.0015,
+        "banding_modulation": 0.2,
+        "noise_modulation": {
+            "dark_gain": 1.0,
+            "depth_gain": 0.4,
+            "fog_gain": 0.6,
+            "max_gain": 2.0,
+        },
+        "shadow_recovery_noise": {
+            "luma_sigma": 0.003,
+            "chroma_sigma": 0.004,
+            "red_chroma_gain": 0.8,
+            "blue_chroma_gain": 2.0,
+            "chroma_axis_correlation": 0.2,
+            "blotch_sigma": 0.005,
+        },
+        "hot_pixel_probability": 0.0002,
+        "dead_pixel_probability": 0.0001,
+    }
+
+    static = capture_module._apply_sensor_noise_adjustment(
+        {
+            **config,
+            "noise_adjustment": {
+                "level": 1.0,
+                "static_chroma_bias": -1.0,
+            },
+        },
+        np.random.default_rng(1),
+    )
+    chroma = capture_module._apply_sensor_noise_adjustment(
+        {
+            **config,
+            "noise_adjustment": {
+                "level": 1.0,
+                "static_chroma_bias": 1.0,
+            },
+        },
+        np.random.default_rng(1),
+    )
+
+    assert static["row_noise_sigma"] > chroma["row_noise_sigma"]
+    assert static["fixed_pattern_sigma"] > chroma["fixed_pattern_sigma"]
+    assert static["hot_pixel_probability"] > chroma["hot_pixel_probability"]
+    assert (
+        static["shadow_recovery_noise"]["chroma_sigma"]
+        < chroma["shadow_recovery_noise"]["chroma_sigma"]
+    )
+    assert (
+        static["shadow_recovery_noise"]["blue_chroma_gain"]
+        < chroma["shadow_recovery_noise"]["blue_chroma_gain"]
+    )
+    assert static["read_noise_sigma"]["min"] < chroma["read_noise_sigma"]["min"]
+    assert static["noise_modulation"]["max_gain"] == chroma["noise_modulation"]["max_gain"]
+
+
+def test_sensor_noise_adjustment_level_changes_output_noise() -> None:
+    base_overrides = {
+        "demosaic": False,
+        "read_noise_sigma": 0.01,
+    }
+    low = _deterministic_sensor_pipeline(
+        auto_exposure={"enabled": False},
+        sensor_overrides={
+            **base_overrides,
+            "noise_adjustment": {"level": 0.0, "static_chroma_bias": 0.0},
+        },
+    )
+    high = _deterministic_sensor_pipeline(
+        auto_exposure={"enabled": False},
+        sensor_overrides={
+            **base_overrides,
+            "noise_adjustment": {"level": 2.0, "static_chroma_bias": 0.0},
+        },
+    )
+    image = np.full((48, 64, 3), 0.5, dtype=np.float32)
+
+    low_result = low.apply_np(image, CaptureContext(rng=np.random.default_rng(7)))
+    high_result = high.apply_np(image, CaptureContext(rng=np.random.default_rng(7)))
+
+    assert float((low_result - image).std()) < 1e-6
+    assert float((high_result - image).std()) > 0.012
+
+
 def test_sensor_auto_exposure_meters_rendered_luminance() -> None:
     pipeline = _deterministic_sensor_pipeline(
         auto_exposure={