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

{euler_preprocess-3.1.0 → euler_preprocess-3.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: euler-preprocess
-Version: 3.1.0
+Version: 3.2.0
 Summary: Physics-based preprocessing (fog, etc.) for RGB+depth datasets
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown

euler_preprocess-3.2.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.2.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.2.0/euler_preprocess/fog/inference.py

@@ -0,0 +1,379 @@
+from __future__ import annotations
+
+import json
+import tempfile
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Literal, Mapping, Sequence
+
+import numpy as np
+
+from euler_preprocess.common.intrinsics import (
+    planar_to_radial_depth,
+    planar_to_radial_depth_torch,
+)
+from euler_preprocess.common.io import load_json
+from euler_preprocess.common.normalize import (
+    _is_chw,
+    _to_numpy,
+    normalize_depth,
+    normalize_rgb,
+    normalize_rgb_torch,
+    normalize_sky_mask,
+)
+from euler_preprocess.common.device import torch_generator_for_index
+from euler_preprocess.fog.transform import FogTransform
+
+try:
+    import torch
+except ImportError:  # pragma: no cover - torch is optional
+    torch = None
+
+
+FogInferenceMode = Literal["cpu", "gpu"]
+
+
+@dataclass(frozen=True)
+class FogInferenceResult:
+    """In-memory fog render output for experimental single-sample inference."""
+
+    rgb: np.ndarray
+    model_name: str
+    beta: float
+    airlight: np.ndarray
+    k_map: np.ndarray
+    ls_map: np.ndarray
+    scenario_name: str | None = None
+
+
+def render_fog_image(
+    *,
+    rgb: Any,
+    depth: Any,
+    semantic_segmentation: Any,
+    intrinsics: Any,
+    config_path: str | Path | None = None,
+    config: Mapping[str, Any] | None = None,
+    scenario_profile_name: str | None = None,
+    mode: FogInferenceMode = "cpu",
+    sample_id: str | None = None,
+    sample_index: int = 0,
+    sky_class: Sequence[int | float] | None = (29, 0, 0),
+) -> np.ndarray:
+    """Render and return only the RGB image for one in-memory sample."""
+
+    return render_fog_sample(
+        rgb=rgb,
+        depth=depth,
+        semantic_segmentation=semantic_segmentation,
+        intrinsics=intrinsics,
+        config_path=config_path,
+        config=config,
+        scenario_profile_name=scenario_profile_name,
+        mode=mode,
+        sample_id=sample_id,
+        sample_index=sample_index,
+        sky_class=sky_class,
+    ).rgb
+
+
+def render_fog_sample(
+    *,
+    rgb: Any,
+    depth: Any,
+    semantic_segmentation: Any,
+    intrinsics: Any,
+    config_path: str | Path | None = None,
+    config: Mapping[str, Any] | None = None,
+    scenario_profile_name: str | None = None,
+    mode: FogInferenceMode = "cpu",
+    sample_id: str | None = None,
+    sample_index: int = 0,
+    sky_class: Sequence[int | float] | None = (29, 0, 0),
+) -> FogInferenceResult:
+    """Render fog/camera artifacts for a single in-memory sample.
+
+    The call accepts the four modalities used by :class:`FogTransform` without
+    requiring a dataset reader or output backend. ``semantic_segmentation`` may
+    be either a boolean sky mask or an RGB semantic label map; RGB maps are
+    converted using ``sky_class`` which defaults to ``[29, 0, 0]``.
+    """
+
+    if mode not in ("cpu", "gpu"):
+        raise ValueError("mode must be 'cpu' or 'gpu'")
+    if config_path is None and config is None:
+        raise ValueError("Either config_path or config must be provided")
+
+    base_config = _load_config(config_path=config_path, config=config)
+    runtime_config = _config_for_mode(base_config, mode)
+
+    with tempfile.TemporaryDirectory(prefix="euler-fog-inference-") as tmpdir:
+        tmp_path = Path(tmpdir)
+        resolved_config_path = tmp_path / "config.json"
+        resolved_config_path.write_text(json.dumps(runtime_config), encoding="utf-8")
+        transform = FogTransform(
+            config_path=str(resolved_config_path),
+            out_path=str(tmp_path / "out"),
+        )
+        return _render_with_transform(
+            transform,
+            rgb=rgb,
+            depth=depth,
+            semantic_segmentation=semantic_segmentation,
+            intrinsics=intrinsics,
+            scenario_profile_name=scenario_profile_name,
+            mode=mode,
+            sample_id=sample_id,
+            sample_index=sample_index,
+            sky_class=sky_class,
+        )
+
+
+def _load_config(
+    *,
+    config_path: str | Path | None,
+    config: Mapping[str, Any] | None,
+) -> dict[str, Any]:
+    if config_path is not None:
+        loaded = load_json(Path(config_path))
+        if config is None:
+            return dict(loaded)
+        merged = dict(loaded)
+        merged.update(dict(config))
+        return merged
+    return dict(config or {})
+
+
+def _config_for_mode(config: dict[str, Any], mode: FogInferenceMode) -> dict[str, Any]:
+    resolved = dict(config)
+    if mode == "cpu":
+        resolved["device"] = "cpu"
+        return resolved
+
+    configured_device = str(resolved.get("device", "")).strip().lower()
+    if configured_device in ("", "cpu"):
+        resolved["device"] = "gpu"
+    return resolved
+
+
+def _render_with_transform(
+    transform: FogTransform,
+    *,
+    rgb: Any,
+    depth: Any,
+    semantic_segmentation: Any,
+    intrinsics: Any,
+    scenario_profile_name: str | None,
+    mode: FogInferenceMode,
+    sample_id: str | None,
+    sample_index: int,
+    sky_class: Sequence[int | float] | None,
+) -> FogInferenceResult:
+    sample_id = sample_id or "inference_sample"
+    rgb_np = normalize_rgb(rgb)
+    depth_np = normalize_depth(
+        depth,
+        rgb_np.shape[:2],
+        transform.resize_depth_flag,
+    )
+    intrinsics_np = _normalize_intrinsics(intrinsics)
+    sky_mask = _normalize_semantic_sky_mask(
+        semantic_segmentation,
+        target_shape=rgb_np.shape[:2],
+        sky_class=sky_class,
+    )
+
+    rng = transform._rng_for(sample_index)
+    scenario = _select_scenario_profile(transform, scenario_profile_name)
+    plan = transform._resolve_render_plan(
+        rng,
+        scenario=scenario,
+        sample_scenario=scenario is None,
+    )
+
+    if mode == "gpu":
+        return _render_gpu(
+            transform,
+            rgb_np=rgb_np,
+            depth_np=depth_np,
+            sky_mask=sky_mask,
+            intrinsics_np=intrinsics_np,
+            plan=plan,
+            rng=rng,
+            sample_id=sample_id,
+            sample_index=sample_index,
+        )
+    return _render_cpu(
+        transform,
+        rgb_np=rgb_np,
+        depth_np=depth_np,
+        sky_mask=sky_mask,
+        intrinsics_np=intrinsics_np,
+        plan=plan,
+        rng=rng,
+        sample_id=sample_id,
+    )
+
+
+def _select_scenario_profile(
+    transform: FogTransform,
+    scenario_profile_name: str | None,
+) -> dict[str, Any] | None:
+    if scenario_profile_name is None:
+        return None
+    for profile in transform.scenario_profiles:
+        if transform._scenario_name(profile) == scenario_profile_name:
+            return profile
+    known = ", ".join(
+        name
+        for name in (
+            transform._scenario_name(profile)
+            for profile in transform.scenario_profiles
+        )
+        if name is not None
+    )
+    raise ValueError(
+        f"Unknown scenario_profile_name '{scenario_profile_name}'. "
+        f"Known: {known or '<none>'}"
+    )
+
+
+def _render_cpu(
+    transform: FogTransform,
+    *,
+    rgb_np: np.ndarray,
+    depth_np: np.ndarray,
+    sky_mask: np.ndarray,
+    intrinsics_np: np.ndarray,
+    plan,
+    rng: np.random.Generator,
+    sample_id: str,
+) -> FogInferenceResult:
+    depth_m = np.maximum(depth_np * transform.depth_scale, 0.0)
+    if intrinsics_np is not None:
+        depth_m = planar_to_radial_depth(depth_m, intrinsics_np)
+
+    result = transform.pipeline.process_np(
+        rgb=rgb_np,
+        depth_m=depth_m,
+        sky_mask=sky_mask,
+        model_name=plan.model_name,
+        model_cfg=plan.model_cfg,
+        rng=rng,
+        sample_id=sample_id,
+        intrinsics=intrinsics_np,
+        airlight_method=plan.airlight_method,
+        capture_artifacts=plan.capture_artifacts,
+    )
+    return FogInferenceResult(
+        rgb=np.asarray(result.rgb, dtype=np.float32),
+        model_name=plan.model_name,
+        beta=float(result.beta),
+        airlight=np.asarray(result.airlight, dtype=np.float32),
+        k_map=np.asarray(result.k_map, dtype=np.float32),
+        ls_map=np.asarray(result.ls_map, dtype=np.float32),
+        scenario_name=plan.scenario_name,
+    )
+
+
+def _render_gpu(
+    transform: FogTransform,
+    *,
+    rgb_np: np.ndarray,
+    depth_np: np.ndarray,
+    sky_mask: np.ndarray,
+    intrinsics_np: np.ndarray,
+    plan,
+    rng: np.random.Generator,
+    sample_id: str,
+    sample_index: int,
+) -> FogInferenceResult:
+    if torch is None or transform.torch_device is None:
+        raise RuntimeError("Torch device not configured for GPU inference")
+
+    device = transform.torch_device
+    rgb_t = normalize_rgb_torch(rgb_np, device)
+    depth_t = torch.from_numpy(depth_np).to(device=device, dtype=torch.float32)
+    depth_t = torch.clamp(depth_t * transform.depth_scale, min=0.0)
+    if intrinsics_np is not None:
+        K_t = torch.from_numpy(intrinsics_np).to(device=device, dtype=torch.float32)
+        depth_t = planar_to_radial_depth_torch(depth_t, K_t)
+
+    sky_mask_t = torch.from_numpy(sky_mask).to(device=device, dtype=torch.bool)
+    estimated_airlight = transform._estimate_airlight_torch(
+        rgb_t,
+        sky_mask_t,
+        sample_id=sample_id,
+        method=plan.airlight_method,
+    )
+    torch_gen = torch_generator_for_index(
+        transform.torch_device,
+        transform.seed,
+        transform.base_rng,
+        sample_index,
+    )
+    foggy_t, beta, airlight_t, k_map_t, ls_map_t = transform._apply_model_torch(
+        rgb_t,
+        depth_t,
+        plan.model_name,
+        plan.model_cfg,
+        rng,
+        estimated_airlight,
+        torch_gen,
+        sample_id=sample_id,
+        intrinsics=intrinsics_np,
+        depth_m=depth_t,
+        capture_artifacts=plan.capture_artifacts,
+    )
+    return FogInferenceResult(
+        rgb=torch.clamp(foggy_t, 0.0, 1.0).detach().cpu().numpy().astype(np.float32),
+        model_name=plan.model_name,
+        beta=float(beta),
+        airlight=airlight_t.detach().cpu().numpy().astype(np.float32),
+        k_map=k_map_t.detach().cpu().numpy().astype(np.float32),
+        ls_map=ls_map_t.detach().cpu().numpy().astype(np.float32),
+        scenario_name=plan.scenario_name,
+    )
+
+
+def _normalize_intrinsics(intrinsics: Any) -> np.ndarray:
+    if isinstance(intrinsics, Mapping):
+        if "intrinsics" in intrinsics:
+            intrinsics = intrinsics["intrinsics"]
+        elif all(key in intrinsics for key in ("fx", "fy", "cx", "cy")):
+            return np.array(
+                [
+                    [float(intrinsics["fx"]), 0.0, float(intrinsics["cx"])],
+                    [0.0, float(intrinsics["fy"]), float(intrinsics["cy"])],
+                    [0.0, 0.0, 1.0],
+                ],
+                dtype=np.float32,
+            )
+    arr = _to_numpy(intrinsics).astype(np.float32)
+    if arr.shape != (3, 3):
+        raise ValueError(f"intrinsics must have shape (3, 3), got {arr.shape}")
+    return arr
+
+
+def _normalize_semantic_sky_mask(
+    semantic_segmentation: Any,
+    *,
+    target_shape: tuple[int, int],
+    sky_class: Sequence[int | float] | None,
+) -> np.ndarray:
+    semantic = _to_numpy(semantic_segmentation)
+    if _is_chw(semantic):
+        semantic = np.transpose(semantic, (1, 2, 0))
+
+    if semantic.ndim == 3 and semantic.shape[-1] >= 3 and sky_class is not None:
+        sky_value = np.asarray(sky_class, dtype=semantic.dtype).reshape(1, 1, -1)
+        mask = np.all(semantic[..., : sky_value.shape[-1]] == sky_value, axis=-1)
+    else:
+        mask = normalize_sky_mask(semantic)
+
+    if mask.shape != target_shape:
+        raise ValueError(
+            f"semantic_segmentation shape {mask.shape} does not match "
+            f"image shape {target_shape}"
+        )
+    return mask.astype(bool, copy=False)

{euler_preprocess-3.1.0 → euler_preprocess-3.2.0}/euler_preprocess/fog/transform.py

@@ -116,6 +116,9 @@ _SCENARIO_CONTROL_KEYS = {
 }
 
 
+_GPU_BATCH_SCOPE_VALUES = {"sample", "batch"}
+
+
 @dataclass(frozen=True)
 class RenderPlan:
     model_name: str
@@ -124,6 +127,23 @@ class RenderPlan:
     capture_artifacts: CaptureArtifactPipeline | None = None
     scenario_name: str | None = None
 
+
+def _freeze_distribution_specs(value: Any, rng: np.random.Generator) -> Any:
+    """Resolve distribution specs while preserving ordinary config structure."""
+    if isinstance(value, dict):
+        if "dist" in value:
+            return sample_value(value, rng)
+        return {
+            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]
+    if isinstance(value, tuple):
+        return tuple(_freeze_distribution_specs(child, rng) for child in value)
+    return value
+
+
 # Use the canonical euler-loading ``generic.map_2d`` / ``map_3d`` modality
 # annotations.  Auxiliary outputs are written as ``.npy`` files in the
 # layout the matching loader expects (``map_2d`` → ``(H, W)``,
@@ -244,6 +264,10 @@ class FogTransform(Transform):
         )
         self.augmentation_specs = list(self.augmentation_config.specs)
         self.scenario_profiles = self._parse_scenario_profiles(self.config)
+        (
+            self.gpu_scenario_scope,
+            self.gpu_condition_parameter_scope,
+        ) = self._parse_gpu_batching_config(self.config)
         self._configure_output_layout_metadata()
         self._written_configs: set[str] = set()
         self.torch_device = None
@@ -317,6 +341,15 @@ class FogTransform(Transform):
             return np.random.default_rng(np.random.SeedSequence(seed_parts))
         return self.base_rng
 
+    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]
+                )
+            )
+        return self.base_rng
+
     def _get_airlight_estimator(self, method: str):
         return self.atmospheric_light.get_estimator(method)
 
@@ -380,6 +413,45 @@ class FogTransform(Transform):
             return tuple(profiles)
         return ()
 
+    def _parse_gpu_batching_config(
+        self,
+        config: dict[str, Any],
+    ) -> tuple[str, str]:
+        raw = config.get("gpu_batching", {})
+        if raw is None or raw is False:
+            raw = {}
+        if raw is True:
+            raw = {"scenario_scope": "batch"}
+        if not isinstance(raw, dict):
+            raise ValueError("gpu_batching must be a boolean or object")
+
+        scenario_scope = str(
+            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'"
+            )
+
+        if "condition_parameter_scope" in raw:
+            condition_scope = str(raw["condition_parameter_scope"]).lower()
+        elif "sample_condition_once_per_batch" in raw:
+            condition_scope = (
+                "batch" if bool(raw["sample_condition_once_per_batch"]) else "sample"
+            )
+        else:
+            condition_scope = "batch" if scenario_scope == "batch" else "sample"
+        if condition_scope not in _GPU_BATCH_SCOPE_VALUES:
+            raise ValueError(
+                "gpu_batching.condition_parameter_scope must be 'sample' or 'batch'"
+            )
+        if condition_scope == "batch" and scenario_scope != "batch":
+            raise ValueError(
+                "gpu_batching.condition_parameter_scope='batch' requires "
+                "scenario_scope='batch'"
+            )
+        return scenario_scope, condition_scope
+
     def _sample_scenario_profile(
         self,
         rng: np.random.Generator,
@@ -466,25 +538,60 @@ class FogTransform(Transform):
         self,
         rng: np.random.Generator,
         augmentation: FogAugmentationSpec | None = None,
+        *,
+        scenario: dict[str, Any] | None = None,
+        sample_scenario: bool = True,
+        freeze_sampled_parameters: bool = False,
     ) -> RenderPlan:
-        scenario = self._sample_scenario_profile(rng)
+        if sample_scenario:
+            scenario = self._sample_scenario_profile(rng)
         if scenario is None:
+            effective_config = (
+                _freeze_distribution_specs(self.config, rng)
+                if freeze_sampled_parameters
+                else self.config
+            )
+            models_cfg = (
+                effective_config.get("models")
+                or effective_config.get("fog_models")
+                or {}
+            )
             if augmentation is not None:
-                model_name, model_cfg = self._resolve_augmented_model(augmentation)
+                base_cfg = resolve_model_config(augmentation.model_name, models_cfg)
+                model_cfg = deep_merge(base_cfg, augmentation.model_overrides)
+                if freeze_sampled_parameters:
+                    model_cfg = _freeze_distribution_specs(model_cfg, rng)
                 return RenderPlan(
-                    model_name=model_name,
+                    model_name=augmentation.model_name,
                     model_cfg=model_cfg,
                     airlight_method=augmentation.airlight_method,
-                )
-            model_name = select_model(self.config, rng)
-            model_cfg = resolve_model_config(model_name, self.models_cfg)
-            return RenderPlan(model_name=model_name, model_cfg=model_cfg)
+                    capture_artifacts=(
+                        CaptureArtifactPipeline.from_config(effective_config)
+                        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:
+                model_cfg = _freeze_distribution_specs(model_cfg, rng)
+            return RenderPlan(
+                model_name=model_name,
+                model_cfg=model_cfg,
+                capture_artifacts=(
+                    CaptureArtifactPipeline.from_config(effective_config)
+                    if freeze_sampled_parameters
+                    else None
+                ),
+            )
 
         payload = self._scenario_payload(scenario)
         effective_config = deep_merge(
             self.config,
             self._scenario_config_override(payload),
         )
+        if freeze_sampled_parameters:
+            effective_config = _freeze_distribution_specs(effective_config, rng)
         models_cfg = (
             effective_config.get("models")
             or effective_config.get("fog_models")
@@ -505,6 +612,8 @@ class FogTransform(Transform):
             model_cfg = resolve_model_config(model_name, models_cfg)
             model_cfg = deep_merge(model_cfg, scenario_overrides)
             airlight_method = self._scenario_airlight_method(payload)
+        if freeze_sampled_parameters:
+            model_cfg = _freeze_distribution_specs(model_cfg, rng)
 
         return RenderPlan(
             model_name=model_name,
@@ -514,6 +623,20 @@ class FogTransform(Transform):
             scenario_name=self._scenario_name(scenario),
         )
 
+    def _resolve_gpu_batch_render_plan(self, batch_index: int) -> RenderPlan | None:
+        if self.gpu_scenario_scope != "batch":
+            return None
+        rng = self._rng_for_batch(batch_index)
+        scenario = self._sample_scenario_profile(rng)
+        return self._resolve_render_plan(
+            rng,
+            scenario=scenario,
+            sample_scenario=False,
+            freeze_sampled_parameters=(
+                self.gpu_condition_parameter_scope == "batch"
+            ),
+        )
+
     def _source_extension(self, sample: dict, backend: Any | None = None) -> str:
         meta = sample.get("meta")
         source_modality = (
@@ -977,7 +1100,10 @@ class FogTransform(Transform):
         saved_paths: list[Path] = []
 
         with progress_bar(total, "GPU", self.logger) as bar:
-            for batch in iter_batches(enumerate(samples), self.gpu_batch_size):
+            for batch_index, batch in enumerate(
+                iter_batches(enumerate(samples), self.gpu_batch_size)
+            ):
+                batch_plan = self._resolve_gpu_batch_render_plan(batch_index)
                 items: list[dict] = []
                 for global_index, sample in batch:
                     rgb = _to_numpy(sample["rgb"])
@@ -993,7 +1119,7 @@ class FogTransform(Transform):
                         )
                     else:
                         rng = self.base_rng
-                    plan = self._resolve_render_plan(rng)
+                    plan = batch_plan or self._resolve_render_plan(rng)
                     items.append(
                         {
                             "sample_id": sample["id"],
@@ -1022,22 +1148,19 @@ class FogTransform(Transform):
                     grouped.setdefault(shape, []).append(item)
 
                 for group_items in grouped.values():
-                    if self.scenario_profiles:
-                        uniform_items = []
-                        other_items = list(group_items)
-                    else:
-                        uniform_items = [
-                            item
-                            for item in group_items
-                            if item["model_name"] == "uniform"
-                        ]
-                        other_items = [
-                            item
-                            for item in group_items
-                            if item["model_name"] != "uniform"
-                        ]
-
-                    if uniform_items:
+                    uniform_groups: dict[int, list[dict]] = {}
+                    other_items = []
+                    for item in group_items:
+                        if item["model_name"] != "uniform":
+                            other_items.append(item)
+                            continue
+                        capture_artifacts = item.get("capture_artifacts")
+                        capture_key = (
+                            0 if capture_artifacts is None else id(capture_artifacts)
+                        )
+                        uniform_groups.setdefault(capture_key, []).append(item)
+
+                    for uniform_items in uniform_groups.values():
                         rgb_batch = torch.stack(
                             [
                                 normalize_rgb_torch(item["rgb"], device)
@@ -1073,6 +1196,7 @@ class FogTransform(Transform):
                                 contrast_threshold_default=(
                                     self.contrast_threshold_default
                                 ),
+                                method=uniform_items[0].get("airlight_method"),
                             )
                         )
                         k_tensor = torch.tensor(
@@ -1082,6 +1206,7 @@ class FogTransform(Transform):
                         foggy = rgb_batch * t[..., None] + ls_base[
                             :, None, None, :
                         ] * (1.0 - t[..., None])
+                        capture_artifacts = uniform_items[0].get("capture_artifacts")
                         foggy = self.pipeline.apply_capture_torch_batch(
                             foggy,
                             contexts=tuple(
@@ -1100,6 +1225,7 @@ class FogTransform(Transform):
                                 )
                                 for idx, item in enumerate(uniform_items)
                             ),
+                            capture_artifacts=capture_artifacts,
                         )
 
                         height = int(rgb_batch.shape[1])

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: euler-preprocess
-Version: 3.1.0
+Version: 3.2.0
 Summary: Physics-based preprocessing (fog, etc.) for RGB+depth datasets
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown

{euler_preprocess-3.1.0 → euler_preprocess-3.2.0}/euler_preprocess.egg-info/SOURCES.txt

@@ -30,6 +30,7 @@ euler_preprocess/fog/dcp_heuristic_airlight.py
 euler_preprocess/fog/dcp_heuristic_airlight_torch.py
 euler_preprocess/fog/foggify.py
 euler_preprocess/fog/foggify_logging.py
+euler_preprocess/fog/inference.py
 euler_preprocess/fog/logging.py
 euler_preprocess/fog/models.py
 euler_preprocess/fog/pipeline.py

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

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

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

@@ -27,6 +27,7 @@ from euler_loading.loaders.cpu.generic import (
 from euler_preprocess.common.output import prepare_output_backends
 import euler_preprocess.fog.capture as capture_module
 from euler_preprocess.fog.capture import CaptureArtifactPipeline, CaptureContext
+from euler_preprocess.fog.inference import render_fog_image, render_fog_sample
 from euler_preprocess.fog.models import visibility_to_k
 from euler_preprocess.fog.transform import (
     ATMOSPHERIC_LIGHT_SLOT,
@@ -1234,6 +1235,174 @@ def test_scenario_profile_correlates_model_and_capture_overrides(
     np.testing.assert_allclose(result.rgb, 0.2)
 
 
+def test_gpu_batching_freezes_batch_condition_parameters(
+    tmp_path: Path,
+) -> None:
+    cfg = {
+        "airlight": "from_sky",
+        "device": "cpu",
+        "seed": 11,
+        "gpu_batch_size": 2,
+        "gpu_batching": {"scenario_scope": "batch"},
+        "capture": {
+            "stages": [
+                {
+                    "type": "sensor",
+                    "enabled": True,
+                    "iso": {"dist": "uniform", "min": 800.0, "max": 1600.0},
+                    "shot_noise_scale": {
+                        "dist": "uniform",
+                        "min": 0.1,
+                        "max": 0.2,
+                    },
+                }
+            ]
+        },
+        "scenario_profiles": [
+            {
+                "name": "batch_dense",
+                "weight": 1.0,
+                "model": "uniform",
+                "models": {
+                    "uniform": {
+                        "visibility_m": {
+                            "dist": "uniform",
+                            "min": 20.0,
+                            "max": 40.0,
+                        },
+                        "atmospheric_light": [0.2, 0.2, 0.2],
+                    }
+                },
+                "capture_overrides": {
+                    "sensor": {
+                        "read_noise_electrons": {
+                            "dist": "uniform",
+                            "min": 2.0,
+                            "max": 4.0,
+                        }
+                    }
+                },
+            }
+        ],
+    }
+    config_path = tmp_path / "gpu_batching_config.json"
+    config_path.write_text(json.dumps(cfg))
+    transform = FogTransform(
+        config_path=str(config_path),
+        out_path=str(tmp_path / "out"),
+    )
+
+    plan = transform._resolve_gpu_batch_render_plan(0)
+
+    assert plan is not None
+    assert transform.gpu_scenario_scope == "batch"
+    assert transform.gpu_condition_parameter_scope == "batch"
+    assert plan.scenario_name == "batch_dense"
+    assert isinstance(plan.model_cfg["visibility_m"], float)
+    assert 20.0 <= plan.model_cfg["visibility_m"] <= 40.0
+    assert plan.capture_artifacts is not None
+    sensor_cfg = plan.capture_artifacts.stages[0].config
+    assert sensor_cfg["enabled"] is True
+    assert isinstance(sensor_cfg["iso"], float)
+    assert isinstance(sensor_cfg["shot_noise_scale"], float)
+    assert isinstance(sensor_cfg["read_noise_electrons"], float)
+
+
+def test_gpu_batch_scenario_keeps_uniform_batch_path(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    torch = pytest.importorskip("torch")
+    cfg = {
+        "airlight": "from_sky",
+        "device": "cpu",
+        "seed": 13,
+        "gpu_batch_size": 2,
+        "gpu_batching": {
+            "scenario_scope": "batch",
+            "condition_parameter_scope": "batch",
+        },
+        "scenario_profiles": [
+            {
+                "name": "batch_uniform",
+                "weight": 1.0,
+                "model": "uniform",
+                "airlight_method": "dcp_heuristic",
+                "models": {
+                    "uniform": {
+                        "visibility_m": 80.0,
+                        "atmospheric_light": [0.35, 0.35, 0.35],
+                    }
+                },
+                "capture": {"stages": []},
+            }
+        ],
+    }
+    config_path = tmp_path / "gpu_batch_uniform_config.json"
+    config_path.write_text(json.dumps(cfg))
+    transform = FogTransform(
+        config_path=str(config_path),
+        out_path=str(tmp_path / "out"),
+    )
+    transform.torch_device = torch.device("cpu")
+
+    calls = []
+    original = transform.pipeline.apply_capture_torch_batch
+    resolve_calls = []
+    original_resolve = transform.atmospheric_light.resolve_uniform_batch_torch
+
+    def spy_apply_capture_torch_batch(
+        rgb_batch,
+        *,
+        contexts,
+        capture_artifacts=None,
+    ):
+        calls.append((len(contexts), capture_artifacts))
+        return original(
+            rgb_batch,
+            contexts=contexts,
+            capture_artifacts=capture_artifacts,
+        )
+
+    def spy_resolve_uniform_batch_torch(**kwargs):
+        resolve_calls.append(kwargs.get("method"))
+        return original_resolve(**kwargs)
+
+    monkeypatch.setattr(
+        transform.pipeline,
+        "apply_capture_torch_batch",
+        spy_apply_capture_torch_batch,
+    )
+    monkeypatch.setattr(
+        transform.atmospheric_light,
+        "resolve_uniform_batch_torch",
+        spy_resolve_uniform_batch_torch,
+    )
+
+    samples = [
+        {
+            "id": "sample_a",
+            "rgb": np.full((4, 5, 3), 0.6, dtype=np.float32),
+            "depth": np.full((4, 5), 10.0, dtype=np.float32),
+            "semantic_segmentation": np.ones((4, 5), dtype=bool),
+        },
+        {
+            "id": "sample_b",
+            "rgb": np.full((4, 5, 3), 0.4, dtype=np.float32),
+            "depth": np.full((4, 5), 12.0, dtype=np.float32),
+            "semantic_segmentation": np.ones((4, 5), dtype=bool),
+        },
+    ]
+
+    saved = transform._generate_fog_gpu(samples)
+
+    assert len(saved) == 2
+    assert len(calls) == 1
+    assert calls[0][0] == 2
+    assert calls[0][1] is not None
+    assert resolve_calls == ["dcp_heuristic"]
+
+
 def test_capture_camera_profile_supplies_stage_defaults() -> None:
     pipeline = CaptureArtifactPipeline.from_config(
         {
@@ -1257,6 +1426,89 @@ def test_capture_camera_profile_supplies_stage_defaults() -> None:
     assert pipeline.stages[0].config["read_noise_electrons"] == 3.0
 
 
+def test_render_fog_sample_accepts_modalities_and_named_scenario() -> None:
+    config = {
+        "airlight": "from_sky",
+        "device": "cpu",
+        "seed": 17,
+        "capture": {
+            "stages": [
+                {
+                    "type": "exposure",
+                    "gain": 1.0,
+                    "condition_profiles": [
+                        {"name": "clean", "weight": 1.0, "gain": 1.0},
+                        {"name": "dark", "weight": 0.0, "gain": 0.25},
+                    ],
+                }
+            ]
+        },
+        "scenario_profiles": [
+            {
+                "name": "clean_reference",
+                "weight": 1.0,
+                "model": "uniform",
+                "models": {
+                    "uniform": {
+                        "visibility_m": 30.0,
+                        "atmospheric_light": [0.2, 0.2, 0.2],
+                    }
+                },
+                "capture_overrides": {"exposure": {"condition_profile": "clean"}},
+            },
+            {
+                "name": "dark_reference",
+                "weight": 1.0,
+                "model": "uniform",
+                "models": {
+                    "uniform": {
+                        "visibility_m": 30.0,
+                        "atmospheric_light": [0.2, 0.2, 0.2],
+                    }
+                },
+                "capture_overrides": {"exposure": {"condition_profile": "dark"}},
+            },
+        ],
+    }
+    rgb = np.full((4, 5, 3), 0.8, dtype=np.float32)
+    depth = np.zeros((4, 5), dtype=np.float32)
+    semantic = np.zeros((4, 5, 3), dtype=np.uint8)
+    semantic[:2, :, :] = np.array([29, 0, 0], dtype=np.uint8)
+    intrinsics = np.array(
+        [[100.0, 0.0, 2.0], [0.0, 100.0, 1.5], [0.0, 0.0, 1.0]],
+        dtype=np.float32,
+    )
+
+    result = render_fog_sample(
+        rgb=rgb,
+        depth=depth,
+        semantic_segmentation=semantic,
+        intrinsics=intrinsics,
+        config=config,
+        scenario_profile_name="dark_reference",
+        mode="cpu",
+    )
+    image = render_fog_image(
+        rgb=rgb,
+        depth=depth,
+        semantic_segmentation=semantic,
+        intrinsics={
+            "fx": 100.0,
+            "fy": 100.0,
+            "cx": 2.0,
+            "cy": 1.5,
+        },
+        config=config,
+        scenario_profile_name="dark_reference",
+        mode="cpu",
+    )
+
+    assert result.scenario_name == "dark_reference"
+    assert result.model_name == "uniform"
+    np.testing.assert_allclose(result.rgb, 0.2)
+    np.testing.assert_allclose(image, result.rgb)
+
+
 def test_optics_stage_uses_intrinsics_principal_point() -> None:
     pipeline = CaptureArtifactPipeline.from_config(
         {