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

{euler_preprocess-3.1.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.1.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.1.0/PKG-INFO → euler_preprocess-3.3.0/README.md

@@ -1,17 +1,3 @@
-Metadata-Version: 2.4
-Name: euler-preprocess
-Version: 3.1.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.3.0/euler_preprocess/fog/__init__.py

@@ -0,0 +1,11 @@
+from euler_preprocess.fog.inference import (
+    FogInferenceResult,
+    render_fog_image,
+    render_fog_sample,
+)
+
+__all__ = [
+    "FogInferenceResult",
+    "render_fog_image",
+    "render_fog_sample",
+]

{euler_preprocess-3.1.0 → euler_preprocess-3.3.0}/euler_preprocess/fog/atmospheric_light.py

@@ -155,12 +155,13 @@ class AtmosphericLightResolver:
         items: list[dict],
         device: Any,
         contrast_threshold_default: float,
+        method: str | None = None,
     ) -> tuple[list[float], "torch.Tensor"]:
         """Resolve beta and dampened base L_s for a uniform-model torch batch."""
         al_spec = items[0]["model_cfg"].get("atmospheric_light", "from_sky")
         airlight_is_estimated = uses_estimated_airlight(al_spec)
         if airlight_is_estimated:
-            ls_base = self._estimate_batch_torch(rgb_batch, items, device)
+            ls_base = self._estimate_batch_torch(rgb_batch, items, device, method)
             ls_base = normalize_atmospheric_light_torch(ls_base)
         else:
             ls_values = []
@@ -209,17 +210,19 @@ class AtmosphericLightResolver:
         rgb_batch: "torch.Tensor",
         items: list[dict],
         device: Any,
+        method: str | None = None,
     ) -> "torch.Tensor":
-        if self.method == "from_sky":
+        resolved_method = method or self.method
+        if resolved_method == "from_sky":
             return self._estimate_from_sky_batch_torch(rgb_batch, items, device)
-        estimator = self._get_estimator_torch(self.method)
+        estimator = self._get_estimator_torch(resolved_method)
         if estimator is None:
             raise RuntimeError(
-                f"Torch airlight estimator unavailable for method '{self.method}'."
+                f"Torch airlight estimator unavailable for method '{resolved_method}'."
             )
         al_list = []
         for idx, item in enumerate(items):
-            if self.method == "dcp":
+            if resolved_method == "dcp":
                 al_list.append(estimator.compute(rgb_batch[idx]))
             else:
                 sky_mask_t = torch.from_numpy(item["sky_mask"]).to(

{euler_preprocess-3.1.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,