sigima 0.0.1.dev0__py3-none-any.whl → 1.0.0__py3-none-any.whl

sigima/tests/signal/fwhm_unit_test.py

@@ -0,0 +1,111 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Unit tests for full width computing features
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# pylint: disable=duplicate-code
+
+from __future__ import annotations
+
+import pytest
+
+import sigima.objects
+import sigima.params
+import sigima.proc.signal
+import sigima.tests.data
+import sigima.tests.helpers
+from sigima.tests import guiutils
+from sigima.tests.env import execenv
+
+
+def __test_fwhm_interactive(obj: sigima.objects.SignalObj, method: str) -> None:
+    """Interactive test for the full width at half maximum computation."""
+    # pylint: disable=import-outside-toplevel
+    from plotpy.builder import make
+
+    from sigima.tests import vistools
+
+    param = sigima.params.FWHMParam.create(method=method)
+    geometry = sigima.proc.signal.fwhm(obj, param)
+    x0, y0, x1, y1 = geometry.coords[0]
+    x, y = obj.xydata
+    vistools.view_curve_items(
+        [
+            make.mcurve(x.real, y.real, label=obj.title),
+            vistools.create_signal_segment(x0, y0, x1, y1, "FWHM"),
+        ],
+        title=f"FWHM [{method}]",
+    )
+
+
+@pytest.mark.gui
+def test_signal_fwhm_interactive() -> None:
+    """FWHM interactive test."""
+    with guiutils.lazy_qt_app_context(force=True):
+        execenv.print("Computing FWHM of a multi-peak signal:")
+        obj1 = sigima.tests.data.create_paracetamol_signal()
+        p = sigima.objects.NormalDistribution1DParam.create(sigma=0.05)
+        obj2 = sigima.tests.data.create_noisy_signal(p)
+        for method, _mname in sigima.params.FWHMParam.methods:
+            execenv.print(f"  Method: {method}")
+            for obj in (obj1, obj2):
+                if method == "zero-crossing":
+                    # Check that a warning is raised when using the zero-crossing method
+                    with pytest.warns(UserWarning):
+                        __test_fwhm_interactive(obj, method)
+                else:
+                    __test_fwhm_interactive(obj, method)
+
+
+@pytest.mark.validation
+def test_signal_fwhm() -> None:
+    """Validation test for the full width at half maximum computation."""
+    obj = sigima.tests.data.get_test_signal("fwhm.txt")
+    real_fwhm = 2.675  # Manual validation
+    for method, exp in (
+        ("gauss", 2.40323),
+        ("lorentz", 2.78072),
+        ("voigt", 2.56591),
+        ("zero-crossing", real_fwhm),
+    ):
+        param = sigima.params.FWHMParam.create(method=method)
+        geometry = sigima.proc.signal.fwhm(obj, param)
+        length = geometry.segments_lengths()[0]
+        sigima.tests.helpers.check_scalar_result(
+            f"FWHM[{method}]", length, exp, rtol=0.05
+        )
+    obj = sigima.tests.data.create_paracetamol_signal()
+    with pytest.warns(UserWarning):
+        sigima.proc.signal.fwhm(
+            obj, sigima.params.FWHMParam.create(method="zero-crossing")
+        )
+
+
+@pytest.mark.validation
+def test_signal_fw1e2() -> None:
+    """Validation test for the full width at 1/e^2 maximum computation."""
+    obj = sigima.tests.data.get_test_signal("fw1e2.txt")
+    exp = 4.06  # Manual validation
+    geometry = sigima.proc.signal.fw1e2(obj)
+    length = geometry.segments_lengths()[0]
+    sigima.tests.helpers.check_scalar_result("FW1E2", length, exp, rtol=0.005)
+
+
+@pytest.mark.validation
+def test_signal_full_width_at_y() -> None:
+    """Validation test for the full width at y computation."""
+    obj = sigima.tests.data.get_test_signal("fwhm.txt")
+    real_fwhm = 2.675  # Manual validation
+    param = sigima.params.OrdinateParam.create(y=0.5)
+    geometry = sigima.proc.signal.full_width_at_y(obj, param)
+    length = geometry.segments_lengths()[0]
+    sigima.tests.helpers.check_scalar_result("∆X", length, real_fwhm, rtol=0.05)
+
+
+if __name__ == "__main__":
+    test_signal_fwhm_interactive()
+    test_signal_fwhm()
+    test_signal_fw1e2()
+    test_signal_full_width_at_y()

sigima/tests/signal/noise_unit_test.py

@@ -0,0 +1,128 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""Unit tests for signal noise addition."""
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+
+import sigima.proc.signal
+from sigima.objects import SineParam, create_signal_from_param
+from sigima.objects.signal import (
+    NormalDistribution1DParam,
+    PoissonDistribution1DParam,
+    UniformDistribution1DParam,
+)
+from sigima.tests import guiutils
+from sigima.tests.helpers import check_array_result, check_scalar_result
+
+
+@pytest.mark.validation
+def test_add_gaussian_noise() -> None:
+    """Test :py:func:`sigima.proc.signal.add_gaussian_noise`."""
+    # Generate source signal.
+    size = 1024
+    param = SineParam.create(size=size, freq=1.0)
+    src = create_signal_from_param(param)
+    # Add Gaussian noise.
+    # Run twice with same parameters to check reproducibility.
+    p = NormalDistribution1DParam.create(seed=42, mu=0.0, sigma=0.1)
+    res1 = sigima.proc.signal.add_gaussian_noise(src, p)
+    res2 = sigima.proc.signal.add_gaussian_noise(src, p)
+
+    guiutils.view_curves_if_gui(
+        [src, res1, res2],
+        title="Gaussian Noise Addition: Noisy images should be identical (same seed)",
+    )
+
+    # X-axis must be preserved.
+    check_array_result("res1.x", res1.x, src.x)
+
+    # Check noise statistics.
+    noise = res1.y - src.y
+    mean_noise = float(np.mean(noise))
+    assert p.mu is not None
+    assert p.sigma is not None
+    expected_error = 5.0 * p.sigma / np.sqrt(src.x.size)
+    check_scalar_result("Mean noise", mean_noise, p.mu, atol=expected_error)
+
+    # Identical results for same seed and distribution parameters.
+    check_array_result("Reproducibility", res1.y, res2.y)
+
+
+@pytest.mark.validation
+def test_add_poisson_noise() -> None:
+    """Test :py:func:`sigima.proc.signal.add_poisson_noise`."""
+    # Generate source signal.
+    size = 1024
+    param = SineParam.create(size=size, freq=1.0)
+    src = create_signal_from_param(param)
+    # Add Poisson noise.
+    # Run twice with same parameters to check reproducibility.
+    p = PoissonDistribution1DParam.create(seed=42, lam=2.0)
+    res1 = sigima.proc.signal.add_poisson_noise(src, p)
+    res2 = sigima.proc.signal.add_poisson_noise(src, p)
+
+    guiutils.view_curves_if_gui(
+        [src, res1, res2],
+        title="Poisson Noise Addition: Noisy signals should be identical (same seed)",
+    )
+
+    # X-axis must be preserved.
+    check_array_result("res1.x", res1.x, src.x)
+
+    # Check noise statistics.
+    noise = res1.y - src.y
+    mean_noise = float(np.mean(noise))
+    assert p.lam is not None
+    # For Poisson distribution, mean equals lambda, but we check with tolerance
+    # since we're adding noise to an existing signal
+    expected_error = 5.0 * np.sqrt(p.lam) / np.sqrt(src.x.size)
+    check_scalar_result("Mean noise", mean_noise, p.lam, atol=expected_error)
+
+    # Identical results for same seed and distribution parameters.
+    check_array_result("Reproducibility", res1.y, res2.y)
+
+
+@pytest.mark.validation
+def test_add_uniform_noise() -> None:
+    """Test :py:func:`sigima.proc.signal.add_uniform_noise`."""
+    # Generate source signal.
+    size = 1024
+    param = SineParam.create(size=size, freq=1.0)
+    src = create_signal_from_param(param)
+    # Add uniform noise.
+    # Run twice with same parameters to check reproducibility.
+    p = UniformDistribution1DParam.create(seed=42, vmin=-0.5, vmax=0.5)
+    res1 = sigima.proc.signal.add_uniform_noise(src, p)
+    res2 = sigima.proc.signal.add_uniform_noise(src, p)
+
+    guiutils.view_curves_if_gui(
+        [src, res1, res2],
+        title="Uniform Noise Addition: Noisy signals should be identical (same seed)",
+    )
+
+    # X-axis must be preserved.
+    check_array_result("res1.x", res1.x, src.x)
+
+    # Check noise statistics.
+    noise = res1.y - src.y
+    mean_noise = float(np.mean(noise))
+    assert p.vmin is not None
+    assert p.vmax is not None
+    expected_mean = (p.vmin + p.vmax) / 2.0
+    # For uniform distribution, standard deviation is (vmax - vmin) / sqrt(12)
+    expected_std = (p.vmax - p.vmin) / np.sqrt(12.0)
+    expected_error = 5.0 * expected_std / np.sqrt(src.x.size)
+    check_scalar_result("Mean noise", mean_noise, expected_mean, atol=expected_error)
+
+    # Identical results for same seed and distribution parameters.
+    check_array_result("Reproducibility", res1.y, res2.y)
+
+
+if __name__ == "__main__":
+    guiutils.enable_gui()
+    test_add_gaussian_noise()
+    test_add_poisson_noise()
+    test_add_uniform_noise()

sigima/tests/signal/offset_correction_unit_test.py

@@ -0,0 +1,34 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Signal offset correction unit test.
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# pylint: disable=duplicate-code
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+
+import sigima.objects
+import sigima.proc.signal
+from sigima.tests.data import create_paracetamol_signal
+
+
+@pytest.mark.validation
+def test_signal_offset_correction() -> None:
+    """Signal offset correction validation test."""
+    s1 = create_paracetamol_signal()
+    param = sigima.objects.ROI1DParam.create(xmin=10.0, xmax=12.0)
+    s2 = sigima.proc.signal.offset_correction(s1, param)
+
+    # Check that the offset correction has been applied
+    imin, imax = np.searchsorted(s1.x, [param.xmin, param.xmax])
+    offset = np.mean(s1.y[imin:imax])
+    assert np.allclose(s2.y, s1.y - offset), "Offset correction failed"
+
+
+if __name__ == "__main__":
+    test_signal_offset_correction()