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

sigima/tests/image/morphology_unit_test.py

@@ -0,0 +1,71 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Unit tests for morphology computation functions.
+"""
+
+from __future__ import annotations
+
+import pytest
+from skimage import morphology
+
+import sigima.objects
+import sigima.params
+import sigima.proc.image
+from sigima.tests.data import get_test_image
+from sigima.tests.helpers import check_array_result
+
+
+def __generic_morphology_validation(method: str) -> None:
+    """Generic test for morphology methods."""
+    # See [1] in sigima\tests\image\__init__.py for more details about the validation.
+    src = get_test_image("flower.npy")
+    p = sigima.params.MorphologyParam.create(radius=10)
+    dst: sigima.objects.ImageObj = getattr(sigima.proc.image, method)(src, p)
+    exp = getattr(morphology, method)(src.data, footprint=morphology.disk(p.radius))
+    check_array_result(f"{method.capitalize()}[radius={p.radius}]", dst.data, exp)
+
+
+@pytest.mark.validation
+def test_white_tophat() -> None:
+    """Validation test for the image white top-hat processing."""
+    __generic_morphology_validation("white_tophat")
+
+
+@pytest.mark.validation
+def test_black_tophat() -> None:
+    """Validation test for the image black top-hat processing."""
+    __generic_morphology_validation("black_tophat")
+
+
+@pytest.mark.validation
+def test_erosion() -> None:
+    """Validation test for the image erosion processing."""
+    __generic_morphology_validation("erosion")
+
+
+@pytest.mark.validation
+def test_dilation() -> None:
+    """Validation test for the image dilation processing."""
+    __generic_morphology_validation("dilation")
+
+
+@pytest.mark.validation
+def test_opening() -> None:
+    """Validation test for the image opening processing."""
+    __generic_morphology_validation("opening")
+
+
+@pytest.mark.validation
+def test_closing() -> None:
+    """Validation test for the image closing processing."""
+    __generic_morphology_validation("closing")
+
+
+if __name__ == "__main__":
+    test_white_tophat()
+    test_black_tophat()
+    test_erosion()
+    test_dilation()
+    test_opening()
+    test_closing()

sigima/tests/image/noise_unit_test.py

@@ -0,0 +1,57 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""Unit tests for image noise addition."""
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+
+import sigima.objects
+import sigima.proc.image
+from sigima.objects import NormalDistribution2DParam
+from sigima.tests import guiutils
+from sigima.tests.helpers import check_array_result, check_scalar_result
+
+
+@pytest.mark.validation
+def test_image_add_gaussian_noise() -> None:
+    """Test :py:func:`sigima.proc.image.add_gaussian_noise`."""
+    # Generate a clean image.
+    size = 512
+    param = sigima.objects.Gauss2DParam.create(height=size, width=size)
+    ima = sigima.objects.create_image_from_param(param)
+    # Add Gaussian noise.
+    # Run twice with same parameters to check reproducibility.
+    p = NormalDistribution2DParam.create(seed=42, mu=0.0, sigma=1.0)
+    res1 = sigima.proc.image.add_gaussian_noise(ima, p)
+    res2 = sigima.proc.image.add_gaussian_noise(ima, p)
+
+    guiutils.view_images_side_by_side_if_gui(
+        [ima, res1, res2],
+        ["Clean", "Noisy (1)", "Noisy (2)"],
+        title=f"Gaussian Noise Addition ({size}x{size}): "
+        f"Noisy images should be identical (same seed)",
+    )
+
+    # Shape must be preserved.
+    assert ima.data is not None
+    assert res1.data is not None
+    assert res1.data.shape == ima.data.shape
+
+    # Check noise statistics.
+    noise = res1.data - ima.data
+    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(ima.data.size)
+    check_scalar_result("Mean noise", mean_noise, p.mu, atol=expected_error)
+
+    # Identical results for same seed and distribution parameters.
+    assert res2.data is not None
+    check_array_result("Reproducibility", res1.data, res2.data)
+
+
+if __name__ == "__main__":
+    guiutils.enable_gui()
+    test_image_add_gaussian_noise()

sigima/tests/image/offset_correction_unit_test.py

@@ -0,0 +1,72 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Image 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.params
+import sigima.proc.image
+from sigima.tests import guiutils
+from sigima.tests.data import create_noisy_gaussian_image
+
+
+@pytest.mark.gui
+def test_image_offset_correction_interactive() -> None:
+    """Image offset correction interactive test."""
+    with guiutils.lazy_qt_app_context(force=True):
+        # pylint: disable=import-outside-toplevel
+        from plotpy.builder import make
+        from plotpy.items import RectangleShape
+        from plotpy.tools import RectangleTool
+        from plotpy.widgets.selectdialog import SelectDialog, select_with_shape_tool
+
+        from sigima.tests import vistools
+
+        i1 = create_noisy_gaussian_image()
+        shape: RectangleShape = select_with_shape_tool(
+            None,
+            RectangleTool,
+            make.image(i1.data, interpolation="nearest", eliminate_outliers=1.0),
+            "Select background area",
+            tooldialogclass=SelectDialog,
+        )
+        if shape is not None:
+            param = sigima.objects.ROI2DParam()
+            # pylint: disable=unbalanced-tuple-unpacking
+            ix0, iy0, ix1, iy1 = i1.physical_to_indices(shape.get_rect())
+            param.x0, param.y0, param.dx, param.dy = ix0, iy0, ix1 - ix0, iy1 - iy0
+            i2 = sigima.proc.image.offset_correction(i1, param)
+            i3 = sigima.proc.image.clip(i2, sigima.params.ClipParam.create(lower=0))
+            vistools.view_images_side_by_side(
+                [i1, i3],
+                titles=["Original image", "Corrected image"],
+                title="Image offset correction and thresholding",
+            )
+
+
+@pytest.mark.validation
+def test_image_offset_correction() -> None:
+    """Image offset correction validation test."""
+    i1 = create_noisy_gaussian_image()
+    p = sigima.objects.ROI2DParam.create(x0=0, y0=0, dx=10, dy=10)
+    i2 = sigima.proc.image.offset_correction(i1, p)
+
+    # Check that the offset correction has been applied
+    ix0, iy0 = int(p.x0), int(p.y0)
+    ix1, iy1 = int(p.x0 + p.dx), int(p.y0 + p.dy)
+    offset = np.mean(i1.data[iy0:iy1, ix0:ix1])
+    assert np.allclose(i2.data, i1.data - offset), "Offset correction failed"
+
+
+if __name__ == "__main__":
+    test_image_offset_correction_interactive()
+    test_image_offset_correction()