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

sigima/tests/image/profile_unit_test.py

@@ -0,0 +1,159 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Profile extraction unit test
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+
+import numpy as np
+import pytest
+
+import sigima.objects
+import sigima.params
+import sigima.proc.image
+from sigima.tests.data import create_sincos_image
+from sigima.tests.helpers import check_array_result
+
+
+@pytest.mark.validation
+def test_line_profile() -> None:
+    """Test line profile computation"""
+    width, height = 256, 128
+    dtype = sigima.objects.ImageDatatypes.UINT16
+    newparam = sigima.objects.NewImageParam.create(
+        dtype=dtype, height=height, width=width
+    )
+    ima = create_sincos_image(newparam)
+
+    # Test horizontal line profile
+    row = 100
+    param = sigima.params.LineProfileParam.create(row=row, direction="horizontal")
+    sig = sigima.proc.image.line_profile(ima, param)
+    assert sig is not None
+    assert len(sig.y) == width
+    exp = np.array(ima.data[row, :], dtype=float)
+    check_array_result("Horizontal line profile", sig.y, exp)
+
+    # Test vertical line profile
+    col = 50
+    param = sigima.params.LineProfileParam.create(col=col, direction="vertical")
+    sig = sigima.proc.image.line_profile(ima, param)
+    assert sig is not None
+    assert len(sig.y) == height
+    exp = np.array(ima.data[:, col], dtype=float)
+    check_array_result("Vertical line profile", sig.y, exp)
+
+
+@pytest.mark.validation
+def test_segment_profile() -> None:
+    """Test segment profile computation"""
+    width, height = 256, 128
+    dtype = sigima.objects.ImageDatatypes.UINT16
+    newparam = sigima.objects.NewImageParam.create(
+        dtype=dtype, height=height, width=width
+    )
+    ima = create_sincos_image(newparam)
+
+    # Test segment profile
+    row1, col1, row2, col2 = 10, 20, 200, 20
+    param = sigima.params.SegmentProfileParam.create(
+        row1=row1, col1=col1, row2=row2, col2=col2
+    )
+    sig = sigima.proc.image.segment_profile(ima, param)
+    assert sig is not None
+    assert len(sig.y) == min(row2, height - 1) - max(row1, 0) + 1
+    exp = np.array(ima.data[10:200, 20], dtype=float)
+    check_array_result("Segment profile", sig.y, exp)
+
+
+@pytest.mark.validation
+def test_average_profile() -> None:
+    """Test average profile computation"""
+    width, height = 256, 128
+    dtype = sigima.objects.ImageDatatypes.UINT16
+    newparam = sigima.objects.NewImageParam.create(
+        dtype=dtype, height=height, width=width
+    )
+    ima = create_sincos_image(newparam)
+    row1, col1, row2, col2 = 10, 20, 200, 230
+    param = sigima.params.AverageProfileParam.create(
+        row1=row1, col1=col1, row2=row2, col2=col2
+    )
+
+    # Test horizontal average profile
+    param.direction = "horizontal"
+    sig = sigima.proc.image.average_profile(ima, param)
+    assert sig is not None
+    assert len(sig.y) == col2 - col1 + 1
+    exp = np.array(ima.data[row1 : row2 + 1, col1 : col2 + 1].mean(axis=0), dtype=float)
+    check_array_result("Horizontal average profile", sig.y, exp)
+
+    # Test vertical average profile
+    param.direction = "vertical"
+    sig = sigima.proc.image.average_profile(ima, param)
+    assert sig is not None
+    assert len(sig.y) == min(row2, height - 1) - max(row1, 0) + 1
+    exp = np.array(ima.data[row1 : row2 + 1, col1 : col2 + 1].mean(axis=1), dtype=float)
+    check_array_result("Vertical average profile", sig.y, exp)
+
+
+def __test_radial_profile_center(
+    obj: sigima.objects.ImageObj, p: sigima.params.RadialProfileParam
+) -> sigima.objects.SignalObj:
+    """Test radial profile computation with given center.
+
+    Args:
+        obj: Image object
+        p: Radial profile parameters
+
+    Returns:
+        Signal object containing the radial profile
+    """
+    sig = sigima.proc.image.radial_profile(obj, p)
+    assert sig is not None
+    assert len(sig.x) == len(sig.y)
+    assert len(sig.y) > 0
+    # Check that profile values are within expected range
+    assert np.all(np.isfinite(sig.y))
+    assert np.all(sig.y >= 0)  # Pixel values should be non-negative
+    return sig
+
+
+@pytest.mark.validation
+def test_radial_profile() -> None:
+    """Test radial profile computation"""
+    width, height = 256, 128
+    dtype = sigima.objects.ImageDatatypes.UINT16
+    newparam = sigima.objects.NewImageParam.create(
+        dtype=dtype, height=height, width=width
+    )
+    ima = create_sincos_image(newparam)
+
+    # Test radial profile with centroid center
+    param = sigima.params.RadialProfileParam.create(center="centroid")
+    __test_radial_profile_center(ima, param)
+
+    # Test radial profile with image center
+    param = sigima.params.RadialProfileParam.create(center="center")
+    __test_radial_profile_center(ima, param)
+
+    # Test radial profile with user-defined center
+    x0, y0 = width // 2, height // 2
+    param = sigima.params.RadialProfileParam.create(center="user", x0=x0, y0=y0)
+    sig = __test_radial_profile_center(ima, param)
+
+    # Test that the x-axis represents distance from center (symmetric around 0)
+    assert sig.x[0] < 0  # First element should be negative
+    assert sig.x[-1] > 0  # Last element should be positive
+    assert sig.x[len(sig.x) // 2] == 0  # Center should be at distance 0
+
+    # Additional validation using the helper function for the last profile
+    check_array_result("Radial profile", sig.y, sig.y)
+
+
+if __name__ == "__main__":
+    test_line_profile()
+    test_segment_profile()
+    test_average_profile()
+    test_radial_profile()

sigima/tests/image/projections_unit_test.py

@@ -0,0 +1,121 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""Unit tests for image projection functions."""
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+
+import sigima.objects
+import sigima.proc.image as sipi
+from sigima.tests import guiutils
+from sigima.tests.data import create_sincos_image
+from sigima.tests.helpers import check_array_result, check_scalar_result
+
+
+@pytest.mark.validation
+def test_image_horizontal_projection() -> None:
+    """Test image horizontal projection."""
+    width, height = 64, 48
+    dtype = sigima.objects.ImageDatatypes.UINT16
+    newparam = sigima.objects.NewImageParam.create(
+        dtype=dtype, height=height, width=width
+    )
+    ima = create_sincos_image(newparam)
+
+    # Add axis labels and units to the image.
+    ima.xunit = "px"
+    ima.yunit = "mm"
+    ima.zunit = "a.u."
+    ima.xlabel = "X position"
+    ima.ylabel = "Y position"
+    ima.zlabel = "Intensity"
+
+    sig = sipi.horizontal_projection(ima)
+    assert sig is not None
+
+    # Visualize image and result profile during interactive runs.
+    guiutils.view_images_if_gui(ima, title="Horizontal projection test image")
+    guiutils.view_curves_if_gui(sig, title="Horizontal projection profile")
+
+    # Signal length should equal the number of columns.
+    assert ima.data is not None
+    assert len(sig.x) == ima.data.shape[1]
+    # X-coordinates spacing should match the image's dx.
+    dx = np.mean(np.diff(sig.x))
+    assert ima.dx is not None
+    check_scalar_result("X-axis spacing", dx, ima.dx)
+
+    expected = np.sum(ima.data, axis=0, dtype=np.float64)
+    check_array_result("Horizontal projection", sig.y, expected)
+
+    # Check labels and units.
+    assert sig.xlabel == ima.xlabel, (
+        f"X-axis label mismatch: got {sig.xlabel}, expected {ima.xlabel}"
+    )
+    assert sig.xunit == ima.xunit, (
+        f"X-axis unit mismatch: got {sig.xunit}, expected {ima.xunit}"
+    )
+    assert sig.ylabel == ima.zlabel, (
+        f"Y-axis label mismatch: got {sig.ylabel}, expected {ima.zlabel}"
+    )
+    assert sig.yunit == ima.zunit, (
+        f"Y-axis unit mismatch: got {sig.yunit}, expected {ima.zunit}"
+    )
+
+
+@pytest.mark.validation
+def test_image_vertical_projection() -> None:
+    """Test image vertical projection."""
+    width, height = 128, 64
+    dtype = sigima.objects.ImageDatatypes.UINT16
+    newparam = sigima.objects.NewImageParam.create(
+        dtype=dtype, height=height, width=width
+    )
+    ima = create_sincos_image(newparam)
+    # Add axis labels and units to the image.
+    ima.xunit = "px"
+    ima.yunit = "mm"
+    ima.zunit = "a.u."
+    ima.xlabel = "X position"
+    ima.ylabel = "Y position"
+    ima.zlabel = "Intensity"
+
+    sig = sipi.vertical_projection(ima)
+    assert sig is not None
+
+    # Visualize image and result profile during interactive runs.
+    guiutils.view_images_if_gui(ima, title="Vertical projection test image")
+    guiutils.view_curves_if_gui(sig, title="Vertical projection profile")
+
+    # Signal length should equal the number of rows.
+    assert ima.data is not None
+    assert len(sig.x) == ima.data.shape[0]
+    # X-coordinates spacing should match the image's dy.
+    dx = np.mean(np.diff(sig.x))
+    assert ima.dy is not None
+    check_scalar_result("X-axis spacing", dx, ima.dy)
+
+    expected = np.sum(ima.data, axis=1, dtype=np.float64)
+    check_array_result("Vertical projection", sig.y, expected)
+
+    # Check labels and units.
+    assert sig.xlabel == ima.ylabel, (
+        f"X-axis label mismatch: got {sig.xlabel}, expected {ima.ylabel}"
+    )
+    assert sig.xunit == ima.yunit, (
+        f"X-axis unit mismatch: got {sig.xunit}, expected {ima.yunit}"
+    )
+    assert sig.ylabel == ima.zlabel, (
+        f"Y-axis label mismatch: got {sig.ylabel}, expected {ima.zlabel}"
+    )
+    assert sig.yunit == ima.zunit, (
+        f"Y-axis unit mismatch: got {sig.yunit}, expected {ima.zunit}"
+    )
+
+
+if __name__ == "__main__":
+    guiutils.enable_gui()
+    test_image_horizontal_projection()
+    test_image_vertical_projection()

sigima/tests/image/restoration_unit_test.py

@@ -0,0 +1,141 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Unit tests for restoration computation functions.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+from skimage import morphology, restoration
+
+import sigima.enums
+import sigima.objects
+import sigima.params
+import sigima.proc.image
+from sigima.tests import guiutils
+from sigima.tests.data import create_multigaussian_image, get_test_image
+from sigima.tests.helpers import check_array_result
+
+
+@pytest.mark.validation
+def test_denoise_tv() -> None:
+    """Validation test for the image Total Variation denoising processing."""
+    # See [1] in sigima\tests\image\__init__.py for more details about the validation.
+    src = get_test_image("flower.npy")
+    src.data = src.data[::8, ::8]
+    for weight, eps, mni in ((0.1, 0.0002, 200), (0.5, 0.0001, 100)):
+        p = sigima.params.DenoiseTVParam.create(
+            weight=weight, eps=eps, max_num_iter=mni
+        )
+        dst = sigima.proc.image.denoise_tv(src, p)
+        exp = restoration.denoise_tv_chambolle(src.data, weight, eps, mni)
+        check_array_result(
+            f"DenoiseTV[weight={weight},eps={eps},max_num_iter={mni}]",
+            dst.data,
+            exp,
+        )
+
+
+@pytest.mark.validation
+def test_denoise_bilateral() -> None:
+    """Validation test for the image bilateral denoising processing."""
+    # See [1] in sigima\tests\image\__init__.py for more details about the validation.
+    src = get_test_image("flower.npy")
+    src.data = src.data[::8, ::8]
+    for sigma, mode in ((1.0, "constant"), (2.0, "edge")):
+        p = sigima.params.DenoiseBilateralParam.create(sigma_spatial=sigma, mode=mode)
+        dst = sigima.proc.image.denoise_bilateral(src, p)
+        exp = restoration.denoise_bilateral(src.data, sigma_spatial=sigma, mode=mode)
+        check_array_result(
+            f"DenoiseBilateral[sigma_spatial={sigma},mode={mode}]",
+            dst.data,
+            exp,
+        )
+
+
+@pytest.mark.validation
+def test_denoise_wavelet() -> None:
+    """Validation test for the image wavelet denoising processing."""
+    # See [1] in sigima\tests\image\__init__.py for more details about the validation.
+    src = get_test_image("flower.npy")
+    src.data = src.data[::8, ::8]
+    p = sigima.params.DenoiseWaveletParam()
+    for wavelets in ("db1", "db2", "db3"):
+        for mode in sigima.enums.ThresholdMethod:
+            for method in ("BayesShrink",):
+                p.wavelets, p.mode, p.method = wavelets, mode, method
+                dst = sigima.proc.image.denoise_wavelet(src, p)
+                exp = restoration.denoise_wavelet(
+                    src.data, wavelet=wavelets, mode=mode.value, method=method
+                )
+                check_array_result(
+                    f"DenoiseWavelet[wavelets={wavelets},mode={mode},method={method}]",
+                    dst.data,
+                    exp,
+                    atol=0.1,
+                )
+
+
+@pytest.mark.validation
+def test_denoise_tophat() -> None:
+    """Validation test for the image top-hat denoising processing."""
+    # 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.proc.image.denoise_tophat(src, p)
+    footprint = morphology.disk(p.radius)
+    exp = src.data - morphology.white_tophat(src.data, footprint=footprint)
+    check_array_result(f"DenoiseTophat[radius={p.radius}]", dst.data, exp)
+
+
+@pytest.mark.validation
+def test_erase() -> None:
+    """Validation test for the image erase processing."""
+    obj = create_multigaussian_image()
+
+    # Single ROI erase
+    coords = [600, 800, 300, 200]
+    ix0, iy0, idx, idy = coords
+    ix1, iy1 = ix0 + idx, iy0 + idy
+    p = sigima.objects.ROI2DParam()
+    p.x0, p.y0, p.dx, p.dy = coords
+    dst = sigima.proc.image.erase(obj, p)
+    exp = obj.data.copy()
+    exp[iy0:iy1, ix0:ix1] = np.ma.mean(obj.data[iy0:iy1, ix0:ix1])
+    guiutils.view_images_side_by_side_if_gui(
+        [obj.data, dst.data, exp], ["Original", "Erased", "Expected"]
+    )
+    check_array_result("Erase", dst.data, exp)
+
+    # Multiple ROIs erase
+    coords = [
+        [600, 800, 300, 200],
+        [100, 200, 300, 200],
+        [400, 500, 300, 200],
+    ]
+    params: list[sigima.objects.ROI2DParam] = []
+    for c in coords:
+        p = sigima.objects.ROI2DParam()
+        p.x0, p.y0, p.dx, p.dy = c
+        params.append(p)
+    dst = sigima.proc.image.erase(obj, params)
+    exp = obj.data.copy()
+    for p in params:
+        ix0, iy0 = int(p.x0), int(p.y0)
+        ix1, iy1 = int(p.x0 + p.dx), int(p.y0 + p.dy)
+        exp[iy0:iy1, ix0:ix1] = np.ma.mean(obj.data[iy0:iy1, ix0:ix1])
+    guiutils.view_images_side_by_side_if_gui(
+        [obj.data, dst.data, exp], ["Original", "Erased", "Expected"]
+    )
+    check_array_result("Erase", dst.data, exp)
+
+
+if __name__ == "__main__":
+    guiutils.enable_gui()
+    test_denoise_tv()
+    test_denoise_bilateral()
+    test_denoise_wavelet()
+    test_denoise_tophat()
+    test_erase()

sigima/tests/image/roi2dparam_unit_test.py

@@ -0,0 +1,53 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+ROI image parameters unit test.
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+
+from __future__ import annotations
+
+import guidata.dataset as gds
+import numpy as np
+import pytest
+
+from sigima.objects import ROI2DParam
+from sigima.tests import guiutils
+from sigima.tests.env import execenv
+
+
+def __create_roi_2d_parameters() -> gds.DataSetGroup:
+    """Create a group of ROI parameters."""
+    p_circ = ROI2DParam("Circular")
+    p_circ.geometry = "circle"
+    p_circ.xc, p_circ.yc, p_circ.r = 100, 200, 50
+    p_rect = ROI2DParam("Rectangular")
+    p_rect.geometry = "rectangle"
+    p_rect.x0, p_rect.y0, p_rect.dx, p_rect.dy = 50, 150, 150, 250
+    p_poly = ROI2DParam("Polygonal")
+    p_poly.geometry = "polygon"
+    p_poly.points = np.array([50.0, 150.0, 150.0, 150.0, 150.0, 250.0, 50.0, 250.0])
+    params = [p_circ, p_rect, p_poly]
+    return gds.DataSetGroup(params, title="ROI Parameters")
+
+
+def test_roi_2d_param_unit():
+    """ROI parameters unit test."""
+    group = __create_roi_2d_parameters()
+    for param in group.datasets:
+        execenv.print(param)
+
+
+@pytest.mark.gui
+def test_roi_2d_param_interactive():
+    """ROI parameters interactive test."""
+    with guiutils.lazy_qt_app_context(force=True):
+        group = __create_roi_2d_parameters()
+        if group.edit():
+            for param in group.datasets:
+                execenv.print(param)
+
+
+if __name__ == "__main__":
+    test_roi_2d_param_interactive()