euler-preprocess 3.8.0__tar.gz → 3.10.0__tar.gz

{euler_preprocess-3.8.0 → euler_preprocess-3.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: euler-preprocess
-Version: 3.8.0
+Version: 3.10.0
 Summary: Physics-based preprocessing (fog, etc.) for RGB+depth datasets
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
@@ -499,12 +499,39 @@ pixels when a sky mask is available.
 
 **RGB** — The clean scene image. Normalised to float32 in [0, 1]. This is the *I(x)* term in the fog equation -- it gets blended with the airlight according to transmittance.
 
-**Depth** — A per-pixel depth map in **metres**. Provides the *d(x)* term in the transmittance calculation `t(x) = exp(-k * d(x))`. Pixels with greater depth receive more fog. Invalid values (NaN, inf, negative) are clamped to zero (treated as infinitely close, receiving no fog).
+**Depth** — A per-pixel depth map in **metres**. Provides the *d(x)* term in the transmittance calculation `t(x) = exp(-k * d(x))`. Pixels with greater depth receive more fog. Invalid values (NaN, inf, negative) are clamped to zero (treated as infinitely close, receiving no fog). By default, depth remains authoritative even where the semantic map says sky. For noisy real-world predictions, `sky_fog_path` can instead derive a density-weighted sky path through a bounded fog layer from the camera intrinsics and assumed orientation.
 
-**Semantic Segmentation** — A per-pixel semantic segmentation map from which a boolean sky mask is derived, loaded via euler-loading's dataset-specific `semantic_segmentation` loader. The sky mask is used for airlight estimation when the `airlight` method is `"from_sky"`: the mean RGB of all sky pixels in the clean image is used as the airlight colour *L_s*.
+**Semantic Segmentation** — A per-pixel semantic segmentation map from which a boolean sky mask is derived, loaded via euler-loading's dataset-specific `semantic_segmentation` loader. The sky mask is used for airlight estimation when the `airlight` method is `"from_sky"`: the mean RGB of all sky pixels in the clean image is used as the airlight colour *L_s*. When `sky_fog_path` is configured, semantic sky pixels use the modeled fog-layer path while depth remains authoritative everywhere else.
 
 **Intrinsics** *(optional)* — When present, planar (z-buffer) depth is converted to radial (Euclidean) depth before fog is applied.
 
+For a bounded valley-fog treatment of sky, add this inside a model config:
+
+```json
+"sky_fog_path": {
+  "mode": "layer",
+  "camera_height_m": 1.6,
+  "fog_valley_peak_m": 80.0,
+  "camera_pitch_deg": 0.0,
+  "camera_roll_deg": 0.0,
+  "density_profile": "linear_fade",
+  "transition_height_m": 10.0,
+  "max_path_m": 1000.0
+}
+```
+
+Pixel rays are reconstructed from the intrinsics. Near-horizon rays accumulate
+long paths through fog, while upward rays exit the layer sooner. The default
+`linear_fade` profile has full density below the transition and decreases
+linearly to zero at `fog_valley_peak_m`; both `camera_height_m` and
+`fog_valley_peak_m` are elevations in the same local vertical coordinate.
+`uniform` keeps full density up to the top. Positive `camera_pitch_deg` points
+the optical axis upward. `max_path_m` bounds horizon rays. The fog-layer path feeds the same fog
+opacity, scene-illumination, and atmospheric-light-gradient heuristics as
+ordinary depth. The original depth is retained for non-sky pixels and capture
+effects. Enabling this option without intrinsics raises an error rather than
+silently reverting to predicted sky depth.
+
 ### Airlight Estimation
 
 The `airlight` config key selects how the atmospheric light *L_s* is estimated:

{euler_preprocess-3.8.0 → euler_preprocess-3.10.0}/README.md

@@ -485,12 +485,39 @@ pixels when a sky mask is available.
 
 **RGB** — The clean scene image. Normalised to float32 in [0, 1]. This is the *I(x)* term in the fog equation -- it gets blended with the airlight according to transmittance.
 
-**Depth** — A per-pixel depth map in **metres**. Provides the *d(x)* term in the transmittance calculation `t(x) = exp(-k * d(x))`. Pixels with greater depth receive more fog. Invalid values (NaN, inf, negative) are clamped to zero (treated as infinitely close, receiving no fog).
+**Depth** — A per-pixel depth map in **metres**. Provides the *d(x)* term in the transmittance calculation `t(x) = exp(-k * d(x))`. Pixels with greater depth receive more fog. Invalid values (NaN, inf, negative) are clamped to zero (treated as infinitely close, receiving no fog). By default, depth remains authoritative even where the semantic map says sky. For noisy real-world predictions, `sky_fog_path` can instead derive a density-weighted sky path through a bounded fog layer from the camera intrinsics and assumed orientation.
 
-**Semantic Segmentation** — A per-pixel semantic segmentation map from which a boolean sky mask is derived, loaded via euler-loading's dataset-specific `semantic_segmentation` loader. The sky mask is used for airlight estimation when the `airlight` method is `"from_sky"`: the mean RGB of all sky pixels in the clean image is used as the airlight colour *L_s*.
+**Semantic Segmentation** — A per-pixel semantic segmentation map from which a boolean sky mask is derived, loaded via euler-loading's dataset-specific `semantic_segmentation` loader. The sky mask is used for airlight estimation when the `airlight` method is `"from_sky"`: the mean RGB of all sky pixels in the clean image is used as the airlight colour *L_s*. When `sky_fog_path` is configured, semantic sky pixels use the modeled fog-layer path while depth remains authoritative everywhere else.
 
 **Intrinsics** *(optional)* — When present, planar (z-buffer) depth is converted to radial (Euclidean) depth before fog is applied.
 
+For a bounded valley-fog treatment of sky, add this inside a model config:
+
+```json
+"sky_fog_path": {
+  "mode": "layer",
+  "camera_height_m": 1.6,
+  "fog_valley_peak_m": 80.0,
+  "camera_pitch_deg": 0.0,
+  "camera_roll_deg": 0.0,
+  "density_profile": "linear_fade",
+  "transition_height_m": 10.0,
+  "max_path_m": 1000.0
+}
+```
+
+Pixel rays are reconstructed from the intrinsics. Near-horizon rays accumulate
+long paths through fog, while upward rays exit the layer sooner. The default
+`linear_fade` profile has full density below the transition and decreases
+linearly to zero at `fog_valley_peak_m`; both `camera_height_m` and
+`fog_valley_peak_m` are elevations in the same local vertical coordinate.
+`uniform` keeps full density up to the top. Positive `camera_pitch_deg` points
+the optical axis upward. `max_path_m` bounds horizon rays. The fog-layer path feeds the same fog
+opacity, scene-illumination, and atmospheric-light-gradient heuristics as
+ordinary depth. The original depth is retained for non-sky pixels and capture
+effects. Enabling this option without intrinsics raises an error rather than
+silently reverting to predicted sky depth.
+
 ### Airlight Estimation
 
 The `airlight` config key selects how the atmospheric light *L_s* is estimated:

{euler_preprocess-3.8.0 → euler_preprocess-3.10.0}/euler_preprocess/fog/models.py

@@ -989,6 +989,170 @@ def _sanitize_depth_torch(depth_m: "torch.Tensor") -> "torch.Tensor":
     return torch.clamp(depth, min=0.0)
 
 
+def _resolve_sky_fog_path_config(
+    model_cfg: dict,
+    rng: np.random.Generator,
+) -> dict | None:
+    raw = model_cfg.get("sky_fog_path")
+    if raw is None or raw is False:
+        return None
+    if not isinstance(raw, dict):
+        raise ValueError("sky_fog_path must be an object or false")
+    enabled = raw.get("enabled", True)
+    if not isinstance(enabled, bool):
+        raise ValueError("sky_fog_path.enabled must be a boolean")
+    if not enabled:
+        return None
+    mode = str(raw.get("mode", "layer")).lower()
+    if mode != "layer":
+        raise ValueError("sky_fog_path.mode must be 'layer'")
+
+    def value(key: str, default: float) -> float:
+        return _sample_float(raw.get(key, default), rng, f"sky_fog_path.{key}")
+
+    camera_height = value("camera_height_m", 1.6)
+    fog_top = value("fog_valley_peak_m", 80.0)
+    transition = value("transition_height_m", 10.0)
+    max_path = value("max_path_m", 1000.0)
+    if transition < 0.0:
+        raise ValueError("sky_fog_path.transition_height_m must be >= 0")
+    if max_path <= 0.0:
+        raise ValueError("sky_fog_path.max_path_m must be > 0")
+    profile = str(raw.get("density_profile", "linear_fade")).lower()
+    if profile not in {"linear_fade", "uniform"}:
+        raise ValueError(
+            "sky_fog_path.density_profile must be 'linear_fade' or 'uniform'"
+        )
+    return {
+        "layer_height_m": max(fog_top - camera_height, 0.0),
+        "transition_height_m": transition,
+        "max_path_m": max_path,
+        "pitch_rad": math.radians(value("camera_pitch_deg", 0.0)),
+        "roll_rad": math.radians(value("camera_roll_deg", 0.0)),
+        "density_profile": profile,
+    }
+
+
+def _camera_up_vector(cfg: dict) -> tuple[float, float, float]:
+    pitch = cfg["pitch_rad"]
+    roll = cfg["roll_rad"]
+    return (
+        math.sin(roll) * math.cos(pitch),
+        -math.cos(roll) * math.cos(pitch),
+        math.sin(pitch),
+    )
+
+
+def apply_sky_fog_path_np(
+    depth_m: np.ndarray,
+    sky_mask: np.ndarray | None,
+    intrinsics: np.ndarray | None,
+    model_cfg: dict,
+    rng: np.random.Generator,
+) -> np.ndarray:
+    """Replace sky depth with its density-weighted path through a fog layer."""
+    cfg = _resolve_sky_fog_path_config(model_cfg, rng)
+    if cfg is None or sky_mask is None:
+        return depth_m
+    if intrinsics is None:
+        raise ValueError("sky_fog_path requires camera intrinsics")
+    depth = np.asarray(depth_m, dtype=np.float32)
+    sky = np.asarray(sky_mask, dtype=bool)
+    if sky.shape != depth.shape:
+        raise ValueError(f"sky_mask must have shape {depth.shape}; got {sky.shape}")
+    K = np.asarray(intrinsics, dtype=np.float32)
+    if K.shape != (3, 3):
+        raise ValueError(f"intrinsics must have shape (3, 3); got {K.shape}")
+
+    height, width = depth.shape
+    yy, xx = np.indices((height, width), dtype=np.float32)
+    pixels = np.stack((xx, yy, np.ones_like(xx)), axis=-1)
+    rays = pixels @ np.linalg.inv(K).T
+    rays /= np.maximum(np.linalg.norm(rays, axis=-1, keepdims=True), 1e-8)
+    up = np.maximum(rays @ np.asarray(_camera_up_vector(cfg), dtype=np.float32), 0.0)
+    layer_height = cfg["layer_height_m"]
+    path = np.full_like(depth, cfg["max_path_m"])
+    if layer_height <= 0.0:
+        path.fill(0.0)
+    else:
+        reached_height = np.minimum(up * cfg["max_path_m"], layer_height)
+        if cfg["density_profile"] == "uniform":
+            vertical_optical_depth = reached_height
+        else:
+            transition = min(cfg["transition_height_m"], layer_height)
+            fade_start = layer_height - transition
+            fade_height = np.clip(reached_height - fade_start, 0.0, transition)
+            vertical_optical_depth = np.minimum(reached_height, fade_start)
+            if transition > 0.0:
+                vertical_optical_depth += fade_height - fade_height**2 / (
+                    2.0 * transition
+                )
+        np.divide(vertical_optical_depth, up, out=path, where=up > 1e-8)
+    return np.where(sky, path, depth).astype(np.float32, copy=False)
+
+
+def apply_sky_fog_path_torch(
+    depth_m: "torch.Tensor",
+    sky_mask: "torch.Tensor | None",
+    intrinsics,
+    model_cfg: dict,
+    rng: np.random.Generator,
+) -> "torch.Tensor":
+    """Torch equivalent of :func:`apply_sky_fog_path_np`."""
+    cfg = _resolve_sky_fog_path_config(model_cfg, rng)
+    if cfg is None or sky_mask is None:
+        return depth_m
+    if intrinsics is None:
+        raise ValueError("sky_fog_path requires camera intrinsics")
+    depth = depth_m.to(dtype=torch.float32)
+    sky = torch.as_tensor(sky_mask, device=depth.device, dtype=torch.bool)
+    if tuple(sky.shape) != tuple(depth.shape):
+        raise ValueError(
+            f"sky_mask must have shape {tuple(depth.shape)}; got {tuple(sky.shape)}"
+        )
+    K = torch.as_tensor(intrinsics, device=depth.device, dtype=depth.dtype)
+    if tuple(K.shape) != (3, 3):
+        raise ValueError(f"intrinsics must have shape (3, 3); got {tuple(K.shape)}")
+
+    height, width = int(depth.shape[0]), int(depth.shape[1])
+    yy, xx = torch.meshgrid(
+        torch.arange(height, device=depth.device, dtype=depth.dtype),
+        torch.arange(width, device=depth.device, dtype=depth.dtype),
+        indexing="ij",
+    )
+    pixels = torch.stack((xx, yy, torch.ones_like(xx)), dim=-1)
+    rays = pixels @ torch.linalg.inv(K).T
+    rays = rays / torch.clamp(torch.linalg.vector_norm(rays, dim=-1, keepdim=True), min=1e-8)
+    up_vector = torch.tensor(_camera_up_vector(cfg), device=depth.device, dtype=depth.dtype)
+    up = torch.clamp(rays @ up_vector, min=0.0)
+    layer_height = cfg["layer_height_m"]
+    if layer_height <= 0.0:
+        path = torch.zeros_like(depth)
+    else:
+        reached_height = torch.clamp(
+            up * cfg["max_path_m"], max=layer_height
+        )
+        if cfg["density_profile"] == "uniform":
+            vertical_optical_depth = reached_height
+        else:
+            transition = min(cfg["transition_height_m"], layer_height)
+            fade_start = layer_height - transition
+            fade_height = torch.clamp(
+                reached_height - fade_start, min=0.0, max=transition
+            )
+            vertical_optical_depth = torch.clamp(reached_height, max=fade_start)
+            if transition > 0.0:
+                vertical_optical_depth = vertical_optical_depth + (
+                    fade_height - fade_height**2 / (2.0 * transition)
+                )
+        path = torch.where(
+            up > 1e-8,
+            vertical_optical_depth / torch.clamp(up, min=1e-8),
+            torch.full_like(up, cfg["max_path_m"]),
+        )
+    return torch.where(sky, path, depth)
+
+
 def _resolve_scene_illumination_config(model_cfg: dict) -> dict:
     raw = model_cfg.get("scene_illumination")
     if raw is None:
@@ -1464,6 +1628,7 @@ def apply_model(
     contrast_threshold_default: float,
     estimated_airlight: np.ndarray,
     sky_mask: np.ndarray | None = None,
+    intrinsics: np.ndarray | None = None,
 ) -> tuple[np.ndarray, float, np.ndarray, np.ndarray, np.ndarray]:
     """Apply a fog model to ``rgb``.
 
@@ -1493,6 +1658,13 @@ def apply_model(
         sampled_al = sample_value(al_spec, rng)
         raw_ls_base = normalize_atmospheric_light(np.asarray(sampled_al))
 
+    depth_m = apply_sky_fog_path_np(
+        depth_m,
+        sky_mask,
+        intrinsics,
+        model_cfg,
+        rng,
+    )
     height, width = depth_m.shape
     ls_base = dampen_airlight(
         raw_ls_base,

{euler_preprocess-3.8.0 → euler_preprocess-3.10.0}/euler_preprocess/fog/pipeline.py

@@ -75,6 +75,7 @@ class FogProcessingPipeline:
         rng: np.random.Generator,
         sample_id: str | None,
         airlight_method: str | None = None,
+        intrinsics: np.ndarray | None = None,
     ) -> FogPipelineResult:
         render_input_space = self.render_input_space_for(model_cfg)
         rgb_for_render = srgb_to_linear(rgb) if render_input_space == "srgb" else rgb
@@ -93,6 +94,7 @@ class FogProcessingPipeline:
             self.contrast_threshold_default,
             estimated_airlight,
             sky_mask=sky_mask,
+            intrinsics=intrinsics,
         )
         if render_input_space == "srgb":
             foggy = linear_to_srgb(foggy)
@@ -193,6 +195,7 @@ class FogProcessingPipeline:
                 rng=rng,
                 sample_id=sample_id,
                 airlight_method=airlight_method,
+                intrinsics=intrinsics,
             )
         return self.apply_capture_np(
             result,

{euler_preprocess-3.8.0 → euler_preprocess-3.10.0}/euler_preprocess/fog/transform.py

@@ -45,6 +45,7 @@ from euler_preprocess.fog.models import (
     AIRLIGHT_METHODS,
     DEFAULT_CONTRAST_THRESHOLD,
     DEFAULT_MODEL_CONFIGS,
+    apply_sky_fog_path_torch,
     apply_ls_gradient_torch,
     modulate_with_noise_torch,
     prepare_noise_field_torch,
@@ -215,8 +216,7 @@ def _freeze_distribution_specs(value: Any, rng: np.random.Generator) -> Any:
         if "dist" in value:
             return sample_value(value, rng)
         return {
-            key: _freeze_distribution_specs(child, rng)
-            for key, child in value.items()
+            key: _freeze_distribution_specs(child, rng) for key, child in value.items()
         }
     if isinstance(value, list):
         return [_freeze_distribution_specs(child, rng) for child in value]
@@ -333,9 +333,7 @@ class FogTransform(Transform):
         self.config_path = Path(config_path)
         if output_backends is not None:
             if "rgb" not in output_backends:
-                raise ValueError(
-                    "output_backends must contain the primary 'rgb' slot"
-                )
+                raise ValueError("output_backends must contain the primary 'rgb' slot")
             self.output_backends = dict(output_backends)
             self.output_backend = self.output_backends["rgb"]
         else:
@@ -457,9 +455,7 @@ class FogTransform(Transform):
     def _rng_for_batch(self, batch_index: int):
         if self.seed is not None:
             return np.random.default_rng(
-                np.random.SeedSequence(
-                    [int(self.seed), int(batch_index), 1_000_003]
-                )
+                np.random.SeedSequence([int(self.seed), int(batch_index), 1_000_003])
             )
         return self.base_rng
 
@@ -524,7 +520,9 @@ class FogTransform(Transform):
         augmentation: FogAugmentationSpec,
     ) -> tuple[str, dict]:
         base_cfg = resolve_model_config(augmentation.model_name, self.models_cfg)
-        return augmentation.model_name, deep_merge(base_cfg, augmentation.model_overrides)
+        return augmentation.model_name, deep_merge(
+            base_cfg, augmentation.model_overrides
+        )
 
     def _parse_scenario_profiles(
         self,
@@ -598,7 +596,9 @@ class FogTransform(Transform):
                     "a finite non-negative number in progressive mode"
                 )
 
-            scenario_name = self._scenario_name(profile) or f"scenario_{scenario_index:03d}"
+            scenario_name = (
+                self._scenario_name(profile) or f"scenario_{scenario_index:03d}"
+            )
             scenario_id = _sanitize_variant_identifier(scenario_name)
             for step_index in range(step_count + 1):
                 weight = (
@@ -644,9 +644,7 @@ class FogTransform(Transform):
             raw.get("scenario_scope", config.get("gpu_scenario_scope", "sample"))
         ).lower()
         if scenario_scope not in _GPU_BATCH_SCOPE_VALUES:
-            raise ValueError(
-                "gpu_batching.scenario_scope must be 'sample' or 'batch'"
-            )
+            raise ValueError("gpu_batching.scenario_scope must be 'sample' or 'batch'")
 
         if "condition_parameter_scope" in raw:
             condition_scope = str(raw["condition_parameter_scope"]).lower()
@@ -808,7 +806,7 @@ class FogTransform(Transform):
                         if freeze_sampled_parameters
                         else None
                     ),
-            )
+                )
             model_name = select_model(effective_config, rng)
             model_cfg = resolve_model_config(model_name, models_cfg)
             if freeze_sampled_parameters:
@@ -831,9 +829,7 @@ class FogTransform(Transform):
         if freeze_sampled_parameters:
             effective_config = _freeze_distribution_specs(effective_config, rng)
         models_cfg = (
-            effective_config.get("models")
-            or effective_config.get("fog_models")
-            or {}
+            effective_config.get("models") or effective_config.get("fog_models") or {}
         )
         scenario_overrides = self._scenario_model_overrides(payload)
 
@@ -952,10 +948,12 @@ class FogTransform(Transform):
             rng,
             self.contrast_threshold_default,
         )
-        target_beta, _target_visibility, _target_contrast = resolve_scattering_coefficient(
-            target_cfg,
-            rng,
-            self.contrast_threshold_default,
+        target_beta, _target_visibility, _target_contrast = (
+            resolve_scattering_coefficient(
+                target_cfg,
+                rng,
+                self.contrast_threshold_default,
+            )
         )
         beta = max(0.0, float(base_beta + (target_beta - base_beta) * weight))
         cfg.pop("visibility_m", None)
@@ -1090,8 +1088,7 @@ class FogTransform(Transform):
             return self._progressive_neutral_number(key, float(target))
         if _is_numeric_sequence(target):
             return [
-                self._progressive_neutral_number(key, float(item))
-                for item in target
+                self._progressive_neutral_number(key, float(item)) for item in target
             ]
         if isinstance(target, dict):
             return {
@@ -1135,9 +1132,7 @@ class FogTransform(Transform):
             rng,
             scenario=scenario,
             sample_scenario=False,
-            freeze_sampled_parameters=(
-                self.gpu_condition_parameter_scope == "batch"
-            ),
+            freeze_sampled_parameters=(self.gpu_condition_parameter_scope == "batch"),
         )
 
     def _source_extension(self, sample: dict, backend: Any | None = None) -> str:
@@ -1158,7 +1153,9 @@ class FogTransform(Transform):
         return raw if isinstance(raw, str) and raw else None
 
     def _augmentation_hierarchy_separator(self, backend: Any) -> str:
-        separator = getattr(getattr(backend, "dataset_writer", None), "_separator", None)
+        separator = getattr(
+            getattr(backend, "dataset_writer", None), "_separator", None
+        )
         if isinstance(separator, str) and separator and separator != "+":
             return separator
         return ":"
@@ -1646,6 +1643,13 @@ class FogTransform(Transform):
             estimated_airlight_t=estimated_airlight_t,
             device=self.torch_device,
         )
+        render_depth_t = apply_sky_fog_path_torch(
+            depth_t,
+            sky_mask,
+            intrinsics,
+            model_cfg,
+            rng,
+        )
         height = int(depth_t.shape[0])
         width = int(depth_t.shape[1])
 
@@ -1694,7 +1698,7 @@ class FogTransform(Transform):
             )
             ls_field = apply_ls_gradient_torch(
                 ls_field,
-                depth_t,
+                render_depth_t,
                 k_field,
                 model_cfg,
                 ls_cfg,
@@ -1706,7 +1710,7 @@ class FogTransform(Transform):
 
         foggy, k_map, ls_map = render_fog_fields_torch(
             rgb_t,
-            depth_t,
+            render_depth_t,
             k_field,
             ls_field,
             model_cfg,
@@ -1817,7 +1821,9 @@ class FogTransform(Transform):
                             "rgb": rgb,
                             "depth": depth,
                             "intrinsics": intrinsics,
-                            "sky_mask": normalize_sky_mask(sample["semantic_segmentation"]),
+                            "sky_mask": normalize_sky_mask(
+                                sample["semantic_segmentation"]
+                            ),
                             "rng": rng,
                             "model_name": plan.model_name,
                             "model_cfg": plan.model_cfg,
@@ -1903,7 +1909,16 @@ class FogTransform(Transform):
                         rendered = [
                             render_fog_fields_torch(
                                 rgb_batch[idx],
-                                depth_tensors[idx],
+                                apply_sky_fog_path_torch(
+                                    depth_tensors[idx],
+                                    torch.from_numpy(item["sky_mask"]).to(
+                                        device=device,
+                                        dtype=torch.bool,
+                                    ),
+                                    item.get("intrinsics"),
+                                    item["model_cfg"],
+                                    item["rng"],
+                                ),
                                 k_means[idx],
                                 ls_base[idx].view(1, 1, 3),
                                 item["model_cfg"],
@@ -1943,9 +1958,7 @@ class FogTransform(Transform):
                         )
 
                         for idx, item in enumerate(uniform_items):
-                            foggy_img = (
-                                torch.clamp(foggy[idx], 0.0, 1.0).cpu().numpy()
-                            )
+                            foggy_img = torch.clamp(foggy[idx], 0.0, 1.0).cpu().numpy()
                             airlight_np = ls_base[idx].detach().cpu().numpy()
                             sample_ref = {
                                 "id": item["sample_id"],
@@ -1997,7 +2010,8 @@ class FogTransform(Transform):
                         K_np = item.get("intrinsics")
                         if K_np is not None:
                             K_t = torch.from_numpy(K_np).to(
-                                device=device, dtype=torch.float32,
+                                device=device,
+                                dtype=torch.float32,
                             )
                             depth_t = planar_to_radial_depth_torch(depth_t, K_t)
                         sky_mask_t = (
@@ -2405,18 +2419,16 @@ class FogTransform(Transform):
                 variant.file_id_hierarchy_name,
             )
             output_basename = f"{variant.id}{backend.output_extension or '.npy'}"
-            attributes = (
-                self._output_variant_attributes(
-                    sample,
-                    variant,
-                    model_name=model_name,
-                    beta=float(beta) if beta is not None else float(np.mean(value)),
-                    airlight=(
-                        airlight
-                        if airlight is not None
-                        else np.asarray([np.nan, np.nan, np.nan], dtype=np.float32)
-                    ),
-                )
+            attributes = self._output_variant_attributes(
+                sample,
+                variant,
+                model_name=model_name,
+                beta=float(beta) if beta is not None else float(np.mean(value)),
+                airlight=(
+                    airlight
+                    if airlight is not None
+                    else np.asarray([np.nan, np.nan, np.nan], dtype=np.float32)
+                ),
             )
             backend.write(
                 sample,

{euler_preprocess-3.8.0 → euler_preprocess-3.10.0}/euler_preprocess.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: euler-preprocess
-Version: 3.8.0
+Version: 3.10.0
 Summary: Physics-based preprocessing (fog, etc.) for RGB+depth datasets
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
@@ -499,12 +499,39 @@ pixels when a sky mask is available.
 
 **RGB** — The clean scene image. Normalised to float32 in [0, 1]. This is the *I(x)* term in the fog equation -- it gets blended with the airlight according to transmittance.
 
-**Depth** — A per-pixel depth map in **metres**. Provides the *d(x)* term in the transmittance calculation `t(x) = exp(-k * d(x))`. Pixels with greater depth receive more fog. Invalid values (NaN, inf, negative) are clamped to zero (treated as infinitely close, receiving no fog).
+**Depth** — A per-pixel depth map in **metres**. Provides the *d(x)* term in the transmittance calculation `t(x) = exp(-k * d(x))`. Pixels with greater depth receive more fog. Invalid values (NaN, inf, negative) are clamped to zero (treated as infinitely close, receiving no fog). By default, depth remains authoritative even where the semantic map says sky. For noisy real-world predictions, `sky_fog_path` can instead derive a density-weighted sky path through a bounded fog layer from the camera intrinsics and assumed orientation.
 
-**Semantic Segmentation** — A per-pixel semantic segmentation map from which a boolean sky mask is derived, loaded via euler-loading's dataset-specific `semantic_segmentation` loader. The sky mask is used for airlight estimation when the `airlight` method is `"from_sky"`: the mean RGB of all sky pixels in the clean image is used as the airlight colour *L_s*.
+**Semantic Segmentation** — A per-pixel semantic segmentation map from which a boolean sky mask is derived, loaded via euler-loading's dataset-specific `semantic_segmentation` loader. The sky mask is used for airlight estimation when the `airlight` method is `"from_sky"`: the mean RGB of all sky pixels in the clean image is used as the airlight colour *L_s*. When `sky_fog_path` is configured, semantic sky pixels use the modeled fog-layer path while depth remains authoritative everywhere else.
 
 **Intrinsics** *(optional)* — When present, planar (z-buffer) depth is converted to radial (Euclidean) depth before fog is applied.
 
+For a bounded valley-fog treatment of sky, add this inside a model config:
+
+```json
+"sky_fog_path": {
+  "mode": "layer",
+  "camera_height_m": 1.6,
+  "fog_valley_peak_m": 80.0,
+  "camera_pitch_deg": 0.0,
+  "camera_roll_deg": 0.0,
+  "density_profile": "linear_fade",
+  "transition_height_m": 10.0,
+  "max_path_m": 1000.0
+}
+```
+
+Pixel rays are reconstructed from the intrinsics. Near-horizon rays accumulate
+long paths through fog, while upward rays exit the layer sooner. The default
+`linear_fade` profile has full density below the transition and decreases
+linearly to zero at `fog_valley_peak_m`; both `camera_height_m` and
+`fog_valley_peak_m` are elevations in the same local vertical coordinate.
+`uniform` keeps full density up to the top. Positive `camera_pitch_deg` points
+the optical axis upward. `max_path_m` bounds horizon rays. The fog-layer path feeds the same fog
+opacity, scene-illumination, and atmospheric-light-gradient heuristics as
+ordinary depth. The original depth is retained for non-sky pixels and capture
+effects. Enabling this option without intrinsics raises an error rather than
+silently reverting to predicted sky depth.
+
 ### Airlight Estimation
 
 The `airlight` config key selects how the atmospheric light *L_s* is estimated:

{euler_preprocess-3.8.0 → euler_preprocess-3.10.0}/pyproject.toml

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

{euler_preprocess-3.8.0 → euler_preprocess-3.10.0}/tests/test_dense_gloomy_daylight_config.py

@@ -54,7 +54,7 @@ def test_dense_gloomy_daylight_config_activates_realism_stack() -> None:
     assert profile["isp"]["tone_map_lut_domain"] == "linear"
     assert len(profile["isp"]["tone_map_lut"]) >= 2
 
-    assert config["scenario_profiles"]
+    assert len(config["scenario_profiles"]) == 6
     clear = _profile_by_name(
         config["scenario_profiles"],
         "clear_weather_camera_reference",
@@ -62,6 +62,13 @@ def test_dense_gloomy_daylight_config_activates_realism_stack() -> None:
     assert clear["clear_weather"] is True
     assert clear["weight"] == 0.1
     assert clear["model"] == "uniform"
+    high_visibility = _profile_by_name(
+        config["scenario_profiles"],
+        "clear_high_visibility_daylight_reference",
+    )
+    assert high_visibility.get("clear_weather", False) is False
+    assert high_visibility["weight"] == 0.09
+    assert high_visibility["model"] == "heterogeneous_k_ls"
     assert sum(scenario["weight"] for scenario in config["scenario_profiles"]) == 1.0
     underexposed_condition = _profile_by_name(
         profile["sensor"]["condition_profiles"],

{euler_preprocess-3.8.0 → euler_preprocess-3.10.0}/tests/test_fog_aux_outputs.py

@@ -46,11 +46,13 @@ def _write_rgb_dataset(root: Path) -> None:
         meta={"range": [0, 255]},
         euler_loading={"loader": "generic_dense_depth", "function": "rgb"},
     )
-    rgb = np.dstack([
-        np.full((4, 6), 32, dtype=np.uint8),
-        np.full((4, 6), 96, dtype=np.uint8),
-        np.full((4, 6), 160, dtype=np.uint8),
-    ])
+    rgb = np.dstack(
+        [
+            np.full((4, 6), 32, dtype=np.uint8),
+            np.full((4, 6), 96, dtype=np.uint8),
+            np.full((4, 6), 160, dtype=np.uint8),
+        ]
+    )
     path = writer.get_path("Scene01/Camera_0/00001", "00001.png")
     write_rgb(str(path), rgb)
     writer.save_index()
@@ -247,7 +249,9 @@ def test_writes_scattering_and_airlight_maps(tmp_path: Path) -> None:
     }
 
     transform = FogTransform(
-        config_path=str(_write_fog_config(tmp_path / "fog_cfg.json", visibility_m=visibility_m)),
+        config_path=str(
+            _write_fog_config(tmp_path / "fog_cfg.json", visibility_m=visibility_m)
+        ),
         out_path=str(backends["rgb"].root),
         output_backends=backends,
     )
@@ -318,20 +322,10 @@ def test_stepped_augmentations_write_file_id_layout_and_attributes(
         assert path.exists()
 
     scattering_path = (
-        pipeline_root
-        / "scattering"
-        / "Scene01"
-        / "Camera_0"
-        / "00001"
-        / "mor_10m.npy"
+        pipeline_root / "scattering" / "Scene01" / "Camera_0" / "00001" / "mor_10m.npy"
     )
     airlight_path = (
-        pipeline_root
-        / "airlight"
-        / "Scene01"
-        / "Camera_0"
-        / "00001"
-        / "mor_10m.npy"
+        pipeline_root / "airlight" / "Scene01" / "Camera_0" / "00001" / "mor_10m.npy"
     )
     assert scattering_path.exists()
     assert airlight_path.exists()
@@ -547,7 +541,9 @@ def test_only_scattering_target_writes_only_scattering(tmp_path: Path) -> None:
     )
     transform.run(dataset)
 
-    assert (pipeline_root / "scattering" / "Scene01" / "Camera_0" / "00001.npy").exists()
+    assert (
+        pipeline_root / "scattering" / "Scene01" / "Camera_0" / "00001.npy"
+    ).exists()
     assert not (pipeline_root / "airlight").exists()
 
 
@@ -1913,13 +1909,7 @@ def _deterministic_sensor_pipeline(
     }
     if sensor_overrides:
         sensor.update(sensor_overrides)
-    return CaptureArtifactPipeline.from_config(
-        {
-            "capture": {
-                "stages": [sensor]
-            }
-        }
-    )
+    return CaptureArtifactPipeline.from_config({"capture": {"stages": [sensor]}})
 
 
 def test_sensor_noise_adjustment_scales_authored_noise_groups() -> None:
@@ -1980,7 +1970,9 @@ def test_sensor_noise_adjustment_scales_authored_noise_groups() -> None:
         < 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"]
+    assert (
+        static["noise_modulation"]["max_gain"] == chroma["noise_modulation"]["max_gain"]
+    )
 
 
 def test_sensor_noise_adjustment_level_changes_output_noise() -> None:
@@ -2880,3 +2872,87 @@ def test_apply_model_accepts_direct_scattering_coefficient() -> None:
 
     assert k_mean == 0.123
     np.testing.assert_allclose(k_map, 0.123)
+
+
+def test_sky_fog_path_uses_ray_angle_and_linear_density_fade() -> None:
+    from euler_preprocess.fog.models import apply_sky_fog_path_np
+
+    depth = np.full((3, 3), 2.0, dtype=np.float32)
+    sky = np.zeros((3, 3), dtype=bool)
+    sky[:, 1] = True
+    intrinsics = np.array(
+        [[1.0, 0.0, 1.0], [0.0, 1.0, 1.0], [0.0, 0.0, 1.0]],
+        dtype=np.float32,
+    )
+    cfg = {
+        "sky_fog_path": {
+            "camera_height_m": 0.0,
+            "fog_valley_peak_m": 10.0,
+            "transition_height_m": 4.0,
+            "max_path_m": 100.0,
+        }
+    }
+
+    result = apply_sky_fog_path_np(
+        depth, sky, intrinsics, cfg, np.random.default_rng(0)
+    )
+
+    # The vertical density integral is 6 m full-density + 2 m fade.
+    np.testing.assert_allclose(result[0, 1], 8.0 * np.sqrt(2.0), rtol=1e-6)
+    assert result[1, 1] == 100.0  # level-camera horizon is capped
+    assert result[2, 1] == 100.0  # downward ray cannot leave through the top
+    assert result[0, 0] == 2.0  # non-sky depth remains untouched
+
+
+def test_sky_fog_path_changes_rendering_without_changing_non_sky_depth() -> None:
+    from euler_preprocess.fog.models import apply_model
+
+    rgb = np.full((3, 3, 3), 0.2, dtype=np.float32)
+    depth = np.full((3, 3), 1.0, dtype=np.float32)
+    sky = np.zeros((3, 3), dtype=bool)
+    sky[:2, 1] = True
+    intrinsics = np.array(
+        [[1.0, 0.0, 1.0], [0.0, 1.0, 1.0], [0.0, 0.0, 1.0]],
+        dtype=np.float32,
+    )
+    cfg = {
+        "scattering_coefficient": 0.1,
+        "atmospheric_light": [0.8, 0.8, 0.8],
+        "sky_fog_path": {
+            "camera_height_m": 0.0,
+            "fog_valley_peak_m": 10.0,
+            "transition_height_m": 4.0,
+            "max_path_m": 100.0,
+        },
+    }
+
+    foggy, _, _, _, _ = apply_model(
+        rgb,
+        depth,
+        "uniform",
+        cfg,
+        np.random.default_rng(0),
+        0.05,
+        np.full(3, 0.8, dtype=np.float32),
+        sky_mask=sky,
+        intrinsics=intrinsics,
+    )
+
+    assert foggy[1, 1, 0] > foggy[0, 1, 0] > foggy[2, 1, 0]
+    np.testing.assert_allclose(
+        foggy[2, 1],
+        0.2 * np.exp(-0.1) + 0.8 * (1.0 - np.exp(-0.1)),
+    )
+
+
+def test_sky_fog_path_requires_intrinsics() -> None:
+    from euler_preprocess.fog.models import apply_sky_fog_path_np
+
+    with pytest.raises(ValueError, match="requires camera intrinsics"):
+        apply_sky_fog_path_np(
+            np.ones((2, 2), dtype=np.float32),
+            np.ones((2, 2), dtype=bool),
+            None,
+            {"sky_fog_path": {"fog_valley_peak_m": 20.0}},
+            np.random.default_rng(0),
+        )

{euler_preprocess-3.8.0 → euler_preprocess-3.10.0}/tests/test_real_drive_sim_scenario_profiles.py

@@ -33,6 +33,7 @@ DEFAULT_RDS_SAMPLE_ZIP = (
 RDS_CONFIG_PATH = Path("configs/dense_gloomy_daylight_fog_camera.json")
 SCENARIO_ORDER = (
     "clear_weather_camera_reference",
+    "clear_high_visibility_daylight_reference",
     "light_haze_soft_overcast",
     "moderate_gloomy_fog_nominal_camera",
     "underexposed_dense_gloom",
@@ -137,10 +138,17 @@ def test_dense_gloomy_scenario_profiles_render_real_drive_sim_samples(
     for sample in rds_samples:
         metrics = _render_scenario_metrics(transform, sample)
 
-        opacity_by_scenario = [
-            metrics[name]["opacity_mean"] for name in SCENARIO_ORDER
-        ]
-        assert opacity_by_scenario == sorted(opacity_by_scenario)
+        clear_metrics = metrics["clear_weather_camera_reference"]
+        assert clear_metrics["beta"] == 0.0
+        assert clear_metrics["opacity_mean"] == 0.0
+        assert clear_metrics["opacity_p95"] == 0.0
+        fog_profiles = SCENARIO_ORDER[1:]
+        assert all(metrics[name]["opacity_mean"] > 0.0 for name in fog_profiles)
+        # Adjacent fog profiles intentionally have overlapping distributions,
+        # so sampled opacity need not be strictly ordered for every image.
+        assert metrics["severe_low_contrast_sensor_stress"]["opacity_mean"] > (
+            metrics["clear_high_visibility_daylight_reference"]["opacity_mean"]
+        )
         assert metrics["severe_low_contrast_sensor_stress"]["opacity_mean"] > (
             metrics["clear_weather_camera_reference"]["opacity_mean"] + 0.25
         )
@@ -151,7 +159,7 @@ def test_dense_gloomy_scenario_profiles_render_real_drive_sim_samples(
         assert metrics["severe_low_contrast_sensor_stress"]["luma_mean"] < (
             metrics["clear_weather_camera_reference"]["luma_mean"] * 0.65
         )
-        chromatically_bounded_profiles = SCENARIO_ORDER[:3]
+        chromatically_bounded_profiles = SCENARIO_ORDER[:4]
         assert all(
             0.75 <= metrics[name]["blue_red_ratio"] <= 1.65
             for name in chromatically_bounded_profiles
@@ -164,7 +172,7 @@ def test_dense_gloomy_scenario_profiles_render_real_drive_sim_samples(
         assert metrics["underexposed_dense_gloom"]["blue_red_ratio"] <= 2.5, {
             sample["id"]: metrics
         }
-        stress_profiles = SCENARIO_ORDER[3:]
+        stress_profiles = SCENARIO_ORDER[4:]
         assert all(
             metrics[name]["blue_minus_red_mean"] <= 0.1 for name in stress_profiles
         ), {sample["id"]: metrics}
@@ -328,7 +336,12 @@ def _render_profile(
     profile: dict[str, Any],
     scenario_index: int,
 ):
-    rng = np.random.default_rng(np.random.SeedSequence([1337, scenario_index, 1]))
+    # Keep the original five profiles on their historical deterministic seeds
+    # when the new clear-weather profile is inserted at the front.
+    stable_scenario_index = max(0, scenario_index - 1)
+    rng = np.random.default_rng(
+        np.random.SeedSequence([1337, stable_scenario_index, 1])
+    )
     plan = transform._resolve_render_plan(
         rng,
         scenario=profile,
@@ -346,6 +359,7 @@ def _render_profile(
         intrinsics=sample["intrinsics"]["intrinsics"],
         airlight_method=plan.airlight_method,
         capture_artifacts=plan.capture_artifacts,
+        clear_weather=plan.clear_weather,
     )