euler-preprocess 3.11.0__tar.gz → 3.13.0__tar.gz

euler_preprocess-3.13.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Daniel Rothenpieler
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

{euler_preprocess-3.11.0/euler_preprocess.egg-info → euler_preprocess-3.13.0}/PKG-INFO

@@ -1,9 +1,12 @@
 Metadata-Version: 2.4
 Name: euler-preprocess
-Version: 3.11.0
+Version: 3.13.0
 Summary: Physics-based preprocessing (fog, etc.) for RGB+depth datasets
+Author-email: Daniel Rothenpieler <rothenpielerdaniel@gmail.com>
+License-Expression: MIT
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
+License-File: LICENSE
 Requires-Dist: numpy
 Requires-Dist: Pillow
 Requires-Dist: euler-loading
@@ -11,12 +14,29 @@ Provides-Extra: gpu
 Requires-Dist: torch; extra == "gpu"
 Provides-Extra: progress
 Requires-Dist: tqdm; extra == "progress"
+Dynamic: license-file
 
-# euler-preprocess
+<!-- euler header — shared across the euler packages.
+     Per package, change only: the <h1>, the tagline, and the badge URLs. -->
+<p align="center">
+  <img src="https://files.chronodle.com/icons/euler.svg" alt="euler" width="96" height="96">
+</p>
 
-Physics-based preprocessing transforms for multi-modal RGB+depth datasets — synthetic
-fog, sky-depth normalisation, and planar-to-radial depth conversion. Built on
-[euler-loading](https://github.com/d-rothen/euler-loading) and
+<h1 align="center">euler-preprocess</h1>
+
+<p align="center">
+  <em>Physics-based preprocessing for multi-modal RGB+depth datasets — synthetic fog, sky-depth normalisation, and planar-to-radial depth conversion.</em>
+</p>
+
+<p align="center">
+  <a href="https://pypi.org/project/euler-preprocess/"><img alt="PyPI" src="https://img.shields.io/pypi/v/euler-preprocess.svg"></a>
+  <a href="https://pypi.org/project/euler-preprocess/"><img alt="Python 3.9+" src="https://img.shields.io/badge/python-3.9%2B-blue.svg"></a>
+  <a href="LICENSE"><img alt="License: MIT" src="https://img.shields.io/badge/license-MIT-blue.svg"></a>
+</p>
+
+---
+
+Built on [euler-loading](https://github.com/d-rothen/euler-loading) and
 [ds-crawler](https://github.com/d-rothen/ds-crawler).
 
 ![Source frame rendered at five meteorological visibility distances](docs/images/fog-visibility-ladder.jpg)
@@ -25,12 +45,13 @@ fog, sky-depth normalisation, and planar-to-radial depth conversion. Built on
 (`configs/fog_stepped_config.json`). Fog density follows the depth map, so the
 attenuation is scene-consistent rather than a flat overlay.*
 
-![Four correlated scene and camera condition profiles](docs/images/camera-scenarios.jpg)
+![Six correlated scene and camera condition profiles](docs/images/camera-scenarios.jpg)
 
-*The same frame through four `scenario_profiles` from
+*The same frame through all six `scenario_profiles` in
 `configs/dense_gloomy_daylight_fog_camera.json`. Each profile samples fog density,
 airlight, exposure, sensor noise and compression together, so weather and camera
-response stay correlated.*
+response stay correlated. The last two are deliberately extreme low-light stress
+cases — their auto-exposure targets a mean luminance of ~0.1.*
 
 Both sets were rendered with `tools/run_fog_qualitative_samples.py`, which runs a
 folder of RGB/depth/segmentation samples through the transform and writes images for
@@ -470,8 +491,14 @@ and dark/fog modulation should move together:
 
 **Tone mapping.** `isp.tone_map` supports `"reinhard"`, `"aces"`, `"clip"`, and
 `"lut"`. The LUT mode interpolates a cheap 1D camera-response curve given by
-`tone_map_lut`, scaled by `tone_map_strength` and interpreted in
-`tone_map_lut_domain`.
+`tone_map_lut` and interpreted in `tone_map_lut_domain`.
+
+For `"lut"` and `"aces"`, `tone_map_strength` is an **exponent on the curve's
+response**, not a linear blend: `0` leaves the image unchanged, `1` applies the
+curve exactly, and values above `1` apply it more strongly. Because the blend is
+geometric, output radiance stays strictly non-negative at any strength. For
+`"reinhard"` the strength is a curve parameter (`x / (1 + strength * x)`) as
+before.
 
 ### Scenario Profiles
 
@@ -653,3 +680,9 @@ The transform config takes no parameters (`{}`); intrinsics are read from the
 CLI runs write a source-backed depth dataset mirroring the input depth modality's layout
 and writer metadata, with `meta.radial_depth` set to `true` in the emitted `index.json`.
 Standalone `RadialTransform(...)` usage keeps the legacy `.npy` output behaviour.
+
+---
+
+## License
+
+[MIT](LICENSE) © Daniel Rothenpieler

euler_preprocess-3.11.0/PKG-INFO → euler_preprocess-3.13.0/README.md

@@ -1,22 +1,24 @@
-Metadata-Version: 2.4
-Name: euler-preprocess
-Version: 3.11.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 — synthetic
-fog, sky-depth normalisation, and planar-to-radial depth conversion. Built on
-[euler-loading](https://github.com/d-rothen/euler-loading) and
+<!-- euler header — shared across the euler packages.
+     Per package, change only: the <h1>, the tagline, and the badge URLs. -->
+<p align="center">
+  <img src="https://files.chronodle.com/icons/euler.svg" alt="euler" width="96" height="96">
+</p>
+
+<h1 align="center">euler-preprocess</h1>
+
+<p align="center">
+  <em>Physics-based preprocessing for multi-modal RGB+depth datasets — synthetic fog, sky-depth normalisation, and planar-to-radial depth conversion.</em>
+</p>
+
+<p align="center">
+  <a href="https://pypi.org/project/euler-preprocess/"><img alt="PyPI" src="https://img.shields.io/pypi/v/euler-preprocess.svg"></a>
+  <a href="https://pypi.org/project/euler-preprocess/"><img alt="Python 3.9+" src="https://img.shields.io/badge/python-3.9%2B-blue.svg"></a>
+  <a href="LICENSE"><img alt="License: MIT" src="https://img.shields.io/badge/license-MIT-blue.svg"></a>
+</p>
+
+---
+
+Built on [euler-loading](https://github.com/d-rothen/euler-loading) and
 [ds-crawler](https://github.com/d-rothen/ds-crawler).
 
 ![Source frame rendered at five meteorological visibility distances](docs/images/fog-visibility-ladder.jpg)
@@ -25,12 +27,13 @@ fog, sky-depth normalisation, and planar-to-radial depth conversion. Built on
 (`configs/fog_stepped_config.json`). Fog density follows the depth map, so the
 attenuation is scene-consistent rather than a flat overlay.*
 
-![Four correlated scene and camera condition profiles](docs/images/camera-scenarios.jpg)
+![Six correlated scene and camera condition profiles](docs/images/camera-scenarios.jpg)
 
-*The same frame through four `scenario_profiles` from
+*The same frame through all six `scenario_profiles` in
 `configs/dense_gloomy_daylight_fog_camera.json`. Each profile samples fog density,
 airlight, exposure, sensor noise and compression together, so weather and camera
-response stay correlated.*
+response stay correlated. The last two are deliberately extreme low-light stress
+cases — their auto-exposure targets a mean luminance of ~0.1.*
 
 Both sets were rendered with `tools/run_fog_qualitative_samples.py`, which runs a
 folder of RGB/depth/segmentation samples through the transform and writes images for
@@ -470,8 +473,14 @@ and dark/fog modulation should move together:
 
 **Tone mapping.** `isp.tone_map` supports `"reinhard"`, `"aces"`, `"clip"`, and
 `"lut"`. The LUT mode interpolates a cheap 1D camera-response curve given by
-`tone_map_lut`, scaled by `tone_map_strength` and interpreted in
-`tone_map_lut_domain`.
+`tone_map_lut` and interpreted in `tone_map_lut_domain`.
+
+For `"lut"` and `"aces"`, `tone_map_strength` is an **exponent on the curve's
+response**, not a linear blend: `0` leaves the image unchanged, `1` applies the
+curve exactly, and values above `1` apply it more strongly. Because the blend is
+geometric, output radiance stays strictly non-negative at any strength. For
+`"reinhard"` the strength is a curve parameter (`x / (1 + strength * x)`) as
+before.
 
 ### Scenario Profiles
 
@@ -653,3 +662,9 @@ The transform config takes no parameters (`{}`); intrinsics are read from the
 CLI runs write a source-backed depth dataset mirroring the input depth modality's layout
 and writer metadata, with `meta.radial_depth` set to `true` in the emitted `index.json`.
 Standalone `RadialTransform(...)` usage keeps the legacy `.npy` output behaviour.
+
+---
+
+## License
+
+[MIT](LICENSE) © Daniel Rothenpieler

{euler_preprocess-3.11.0 → euler_preprocess-3.13.0}/euler_preprocess/fog/capture.py

@@ -4960,6 +4960,48 @@ def _apply_bad_pixels_torch(
     return out
 
 
+# Radiance floor used when blending tone curves in log space, and the bounds
+# applied to the log-space result so extreme strengths cannot overflow ``exp``.
+_TONE_CURVE_FLOOR = 1e-8
+_TONE_CURVE_LOG_MIN = -80.0
+_TONE_CURVE_LOG_MAX = 20.0
+
+
+def _blend_tone_curve_np(
+    image: np.ndarray,
+    mapped: np.ndarray,
+    strength: float,
+) -> np.ndarray:
+    """Apply a tone curve with ``strength`` acting as an exponent on its response.
+
+    The blend is geometric rather than linear: ``strength`` exponentiates the
+    per-pixel response ratio ``mapped / image``, so ``0`` returns the input
+    unchanged, ``1`` reproduces the curve exactly, and values above ``1`` apply
+    the curve more strongly. A linear blend extrapolates through zero once
+    ``strength`` exceeds ``1 / (1 - toe_slope)``, which drives every shadow
+    pixel negative and clips whole frames to black; the geometric form stays
+    strictly non-negative for any strength.
+    """
+    if strength == 1.0:
+        return np.asarray(mapped, dtype=np.float32)
+    if strength == 0.0:
+        return np.asarray(image, dtype=np.float32)
+
+    image = np.asarray(image, dtype=np.float32)
+    mapped = np.asarray(mapped, dtype=np.float32)
+    log_image = np.log(np.maximum(image, _TONE_CURVE_FLOOR))
+    log_mapped = np.log(np.maximum(mapped, _TONE_CURVE_FLOOR))
+    log_blend = np.clip(
+        log_image + strength * (log_mapped - log_image),
+        _TONE_CURVE_LOG_MIN,
+        _TONE_CURVE_LOG_MAX,
+    )
+    return np.where(image > 0.0, np.exp(log_blend), 0.0).astype(
+        np.float32,
+        copy=False,
+    )
+
+
 def _apply_tone_map_np(
     image: np.ndarray,
     mode: str,
@@ -4977,18 +5019,33 @@ def _apply_tone_map_np(
         d = 0.59
         e = 0.14
         mapped = (img * (a * img + b)) / (img * (c * img + d) + e)
-        return img * (1.0 - strength) + mapped * strength
+        return _blend_tone_curve_np(img, mapped, strength)
     if mode == "clip":
         return _clip01(img)
     if mode == "lut":
         mapped = _apply_tone_map_lut_np(img, config or {})
-        return (img * (1.0 - strength) + mapped * strength).astype(
-            np.float32,
-            copy=False,
-        )
+        return _blend_tone_curve_np(img, mapped, strength)
     raise ValueError(f"Unsupported tone_map: {mode}")
 
 
+def _blend_tone_curve_torch(image, mapped, strength: float):
+    """Torch counterpart of :func:`_blend_tone_curve_np`."""
+    if strength == 1.0:
+        return mapped
+    if strength == 0.0:
+        return image
+
+    log_image = torch.log(torch.clamp(image, min=_TONE_CURVE_FLOOR))
+    log_mapped = torch.log(torch.clamp(mapped, min=_TONE_CURVE_FLOOR))
+    log_blend = torch.clamp(
+        log_image + strength * (log_mapped - log_image),
+        min=_TONE_CURVE_LOG_MIN,
+        max=_TONE_CURVE_LOG_MAX,
+    )
+    blended = torch.exp(log_blend)
+    return torch.where(image > 0.0, blended, torch.zeros_like(blended))
+
+
 def _apply_tone_map_torch(
     image,
     mode: str,
@@ -5006,12 +5063,12 @@ def _apply_tone_map_torch(
         d = 0.59
         e = 0.14
         mapped = (img * (a * img + b)) / (img * (c * img + d) + e)
-        return img * (1.0 - strength) + mapped * strength
+        return _blend_tone_curve_torch(img, mapped, strength)
     if mode == "clip":
         return _clip01_torch(img)
     if mode == "lut":
         mapped = _apply_tone_map_lut_torch(img, config or {})
-        return img * (1.0 - strength) + mapped * strength
+        return _blend_tone_curve_torch(img, mapped, strength)
     raise ValueError(f"Unsupported tone_map: {mode}")
 
 

euler_preprocess-3.11.0/README.md → euler_preprocess-3.13.0/euler_preprocess.egg-info/PKG-INFO

@@ -1,8 +1,42 @@
-# euler-preprocess
+Metadata-Version: 2.4
+Name: euler-preprocess
+Version: 3.13.0
+Summary: Physics-based preprocessing (fog, etc.) for RGB+depth datasets
+Author-email: Daniel Rothenpieler <rothenpielerdaniel@gmail.com>
+License-Expression: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+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"
+Dynamic: license-file
+
+<!-- euler header — shared across the euler packages.
+     Per package, change only: the <h1>, the tagline, and the badge URLs. -->
+<p align="center">
+  <img src="https://files.chronodle.com/icons/euler.svg" alt="euler" width="96" height="96">
+</p>
+
+<h1 align="center">euler-preprocess</h1>
+
+<p align="center">
+  <em>Physics-based preprocessing for multi-modal RGB+depth datasets — synthetic fog, sky-depth normalisation, and planar-to-radial depth conversion.</em>
+</p>
+
+<p align="center">
+  <a href="https://pypi.org/project/euler-preprocess/"><img alt="PyPI" src="https://img.shields.io/pypi/v/euler-preprocess.svg"></a>
+  <a href="https://pypi.org/project/euler-preprocess/"><img alt="Python 3.9+" src="https://img.shields.io/badge/python-3.9%2B-blue.svg"></a>
+  <a href="LICENSE"><img alt="License: MIT" src="https://img.shields.io/badge/license-MIT-blue.svg"></a>
+</p>
 
-Physics-based preprocessing transforms for multi-modal RGB+depth datasets — synthetic
-fog, sky-depth normalisation, and planar-to-radial depth conversion. Built on
-[euler-loading](https://github.com/d-rothen/euler-loading) and
+---
+
+Built on [euler-loading](https://github.com/d-rothen/euler-loading) and
 [ds-crawler](https://github.com/d-rothen/ds-crawler).
 
 ![Source frame rendered at five meteorological visibility distances](docs/images/fog-visibility-ladder.jpg)
@@ -11,12 +45,13 @@ fog, sky-depth normalisation, and planar-to-radial depth conversion. Built on
 (`configs/fog_stepped_config.json`). Fog density follows the depth map, so the
 attenuation is scene-consistent rather than a flat overlay.*
 
-![Four correlated scene and camera condition profiles](docs/images/camera-scenarios.jpg)
+![Six correlated scene and camera condition profiles](docs/images/camera-scenarios.jpg)
 
-*The same frame through four `scenario_profiles` from
+*The same frame through all six `scenario_profiles` in
 `configs/dense_gloomy_daylight_fog_camera.json`. Each profile samples fog density,
 airlight, exposure, sensor noise and compression together, so weather and camera
-response stay correlated.*
+response stay correlated. The last two are deliberately extreme low-light stress
+cases — their auto-exposure targets a mean luminance of ~0.1.*
 
 Both sets were rendered with `tools/run_fog_qualitative_samples.py`, which runs a
 folder of RGB/depth/segmentation samples through the transform and writes images for
@@ -456,8 +491,14 @@ and dark/fog modulation should move together:
 
 **Tone mapping.** `isp.tone_map` supports `"reinhard"`, `"aces"`, `"clip"`, and
 `"lut"`. The LUT mode interpolates a cheap 1D camera-response curve given by
-`tone_map_lut`, scaled by `tone_map_strength` and interpreted in
-`tone_map_lut_domain`.
+`tone_map_lut` and interpreted in `tone_map_lut_domain`.
+
+For `"lut"` and `"aces"`, `tone_map_strength` is an **exponent on the curve's
+response**, not a linear blend: `0` leaves the image unchanged, `1` applies the
+curve exactly, and values above `1` apply it more strongly. Because the blend is
+geometric, output radiance stays strictly non-negative at any strength. For
+`"reinhard"` the strength is a curve parameter (`x / (1 + strength * x)`) as
+before.
 
 ### Scenario Profiles
 
@@ -639,3 +680,9 @@ The transform config takes no parameters (`{}`); intrinsics are read from the
 CLI runs write a source-backed depth dataset mirroring the input depth modality's layout
 and writer metadata, with `meta.radial_depth` set to `true` in the emitted `index.json`.
 Standalone `RadialTransform(...)` usage keeps the legacy `.npy` output behaviour.
+
+---
+
+## License
+
+[MIT](LICENSE) © Daniel Rothenpieler

{euler_preprocess-3.11.0 → euler_preprocess-3.13.0}/euler_preprocess.egg-info/SOURCES.txt

@@ -1,3 +1,4 @@
+LICENSE
 MANIFEST.in
 README.md
 pyproject.toml

{euler_preprocess-3.11.0 → euler_preprocess-3.13.0}/pyproject.toml

@@ -1,9 +1,18 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
 [project]
 name = "euler-preprocess"
-version = "3.11.0"
+version = "3.13.0"
 description = "Physics-based preprocessing (fog, etc.) for RGB+depth datasets"
 readme = "README.md"
 requires-python = ">=3.9"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [
+  { name = "Daniel Rothenpieler", email = "rothenpielerdaniel@gmail.com" },
+]
 dependencies = [
   "numpy",
   "Pillow",

euler_preprocess-3.13.0/tests/test_tone_map_lut.py

@@ -0,0 +1,139 @@
+from __future__ import annotations
+
+import numpy as np
+import pytest
+
+from euler_preprocess.fog.capture import (
+    CaptureArtifactPipeline,
+    CaptureContext,
+    _apply_tone_map_np,
+)
+
+try:
+    import torch
+
+    from euler_preprocess.fog.capture import _apply_tone_map_torch
+except ImportError:
+    torch = None
+
+# A camera-response curve whose toe compresses shadows ~11x, matching the
+# profiles in configs/dense_gloomy_daylight_fog_camera.json.
+TOE_LUT = [
+    0.0, 0.006, 0.014, 0.028, 0.052, 0.090, 0.145, 0.220,
+    0.320, 0.450, 0.610, 0.780, 0.900, 0.965, 0.995, 1.0,
+]
+LUT_CONFIG = {"tone_map_lut": TOE_LUT, "tone_map_lut_domain": "linear"}
+# Shadow values below the LUT's linear toe, where a linear strength blend used
+# to extrapolate through zero at strength ~= 1/(1 - 0.09) = 1.0989.
+SHADOWS = np.asarray(
+    [[[0.005, 0.005, 0.005], [0.0145, 0.0145, 0.0145], [0.03, 0.03, 0.03]]],
+    dtype=np.float32,
+)
+
+
+def _isp_pipeline(**overrides):
+    stage = {
+        "type": "isp",
+        "denoise_sigma": 0.0,
+        "color_matrix": [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]],
+        "tone_map": "lut",
+        "tone_map_strength": 1.0,
+        "tone_map_lut": TOE_LUT,
+        "gamma": "linear",
+        "local_contrast_strength": 0.0,
+        "sharpen_amount": 0.0,
+        "saturation": 1.0,
+    }
+    stage.update(overrides)
+    return CaptureArtifactPipeline.from_config({"capture": {"stages": [stage]}})
+
+
+def test_isp_tone_map_lut_interpolates_1d_curve() -> None:
+    pipeline = _isp_pipeline(tone_map_lut=[0.0, 0.25, 1.0])
+    image = np.asarray([[[0.0, 0.5, 1.0]]], dtype=np.float32)
+
+    result = pipeline.apply_np(image, CaptureContext(rng=np.random.default_rng(9)))
+
+    np.testing.assert_allclose(result, [[[0.0, 0.25, 1.0]]], atol=1e-6)
+
+
+def test_tone_map_strength_zero_is_identity() -> None:
+    result = _apply_tone_map_np(SHADOWS, "lut", 0.0, LUT_CONFIG)
+
+    np.testing.assert_allclose(result, SHADOWS, atol=1e-7)
+
+
+def test_tone_map_strength_one_reproduces_curve_exactly() -> None:
+    result = _apply_tone_map_np(SHADOWS, "lut", 1.0, LUT_CONFIG)
+
+    expected = np.interp(
+        SHADOWS,
+        np.linspace(0.0, 1.0, len(TOE_LUT)),
+        np.asarray(TOE_LUT, dtype=np.float32),
+    )
+    np.testing.assert_allclose(result, expected, atol=1e-6)
+
+
+@pytest.mark.parametrize("strength", [1.05, 1.0989, 1.119, 1.22, 2.0, 8.0])
+def test_tone_map_strength_above_one_never_goes_negative(strength: float) -> None:
+    """A linear blend crossed zero here and clipped whole frames to black."""
+    result = _apply_tone_map_np(SHADOWS, "lut", strength, LUT_CONFIG)
+
+    assert np.isfinite(result).all()
+    assert float(result.min()) > 0.0
+
+
+def test_isp_does_not_black_out_shadows_at_strength_above_one() -> None:
+    """End-to-end guard: the ISP must not crush a dark frame to zero."""
+    pipeline = _isp_pipeline(tone_map_strength=1.22, gamma="srgb")
+
+    result = pipeline.apply_np(SHADOWS, CaptureContext(rng=np.random.default_rng(9)))
+
+    assert float(result.min()) > 0.0
+    assert float(np.median(result)) > 1e-4
+
+
+def test_tone_map_strength_is_monotonic_and_bounded() -> None:
+    previous = None
+    for strength in np.linspace(0.0, 4.0, 41):
+        result = _apply_tone_map_np(SHADOWS, "lut", float(strength), LUT_CONFIG)
+        assert np.isfinite(result).all()
+        assert float(result.min()) >= 0.0
+        if previous is not None:
+            # A compressive curve only darkens further as strength rises.
+            assert (result <= previous + 1e-6).all()
+        previous = result
+
+
+def test_tone_map_preserves_black_and_survives_extreme_strength() -> None:
+    image = np.zeros((1, 1, 3), dtype=np.float32)
+    assert float(_apply_tone_map_np(image, "lut", 3.0, LUT_CONFIG).max()) == 0.0
+
+    result = _apply_tone_map_np(SHADOWS, "lut", 1e6, LUT_CONFIG)
+    assert np.isfinite(result).all()
+    assert float(result.min()) >= 0.0
+
+
+@pytest.mark.parametrize("strength", [0.0, 1.0, 1.3, 5.0])
+def test_aces_tone_map_stays_non_negative(strength: float) -> None:
+    result = _apply_tone_map_np(SHADOWS, "aces", strength, None)
+
+    assert np.isfinite(result).all()
+    assert float(result.min()) >= 0.0
+
+
+@pytest.mark.skipif(torch is None, reason="torch not installed")
+@pytest.mark.parametrize("mode", ["lut", "aces"])
+@pytest.mark.parametrize("strength", [0.0, 0.5, 1.0, 1.119, 2.0])
+def test_torch_tone_map_matches_numpy(mode: str, strength: float) -> None:
+    config = LUT_CONFIG if mode == "lut" else None
+    expected = _apply_tone_map_np(SHADOWS, mode, strength, config)
+
+    actual = _apply_tone_map_torch(
+        torch.from_numpy(SHADOWS.copy()),
+        mode,
+        strength,
+        config,
+    )
+
+    np.testing.assert_allclose(actual.numpy(), expected, atol=1e-6)

euler_preprocess-3.11.0/tests/test_tone_map_lut.py

@@ -1,37 +0,0 @@
-from __future__ import annotations
-
-import numpy as np
-
-from euler_preprocess.fog.capture import CaptureArtifactPipeline, CaptureContext
-
-
-def test_isp_tone_map_lut_interpolates_1d_curve() -> None:
-    pipeline = CaptureArtifactPipeline.from_config(
-        {
-            "capture": {
-                "stages": [
-                    {
-                        "type": "isp",
-                        "denoise_sigma": 0.0,
-                        "color_matrix": [
-                            [1.0, 0.0, 0.0],
-                            [0.0, 1.0, 0.0],
-                            [0.0, 0.0, 1.0],
-                        ],
-                        "tone_map": "lut",
-                        "tone_map_strength": 1.0,
-                        "tone_map_lut": [0.0, 0.25, 1.0],
-                        "gamma": "linear",
-                        "local_contrast_strength": 0.0,
-                        "sharpen_amount": 0.0,
-                        "saturation": 1.0,
-                    }
-                ]
-            }
-        }
-    )
-    image = np.asarray([[[0.0, 0.5, 1.0]]], dtype=np.float32)
-
-    result = pipeline.apply_np(image, CaptureContext(rng=np.random.default_rng(9)))
-
-    np.testing.assert_allclose(result, [[[0.0, 0.25, 1.0]]], atol=1e-6)