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

sigima/tests/image/contour_unit_test.py

@@ -0,0 +1,172 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Contour finding test
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# pylint: disable=duplicate-code
+
+import sys
+import time
+
+import numpy as np
+import pytest
+
+from sigima.enums import ContourShape
+from sigima.tests import guiutils
+from sigima.tests.data import get_peak2d_data
+from sigima.tests.env import execenv
+from sigima.tests.helpers import check_scalar_result
+from sigima.tools import coordinates
+from sigima.tools.image import get_2d_peaks_coords, get_contour_shapes
+
+
+def create_contour_shape_items(data, shape):
+    """Create plotpy items for a specific contour shape.
+
+    Args:
+        data: Input data array
+        shape: ContourShape enum value
+
+    Returns:
+        List of plotpy items representing the detected contours
+    """
+    # pylint: disable=import-outside-toplevel
+    from plotpy.builder import make
+
+    items = []
+    coords = get_contour_shapes(data, shape=shape)
+    execenv.print(f"Coordinates ({shape}s): {coords}")
+    for shapeargs in coords:
+        if shape == ContourShape.CIRCLE:
+            xc, yc, r = shapeargs
+            x0, y0, x1, y1 = coordinates.circle_to_diameter(xc, yc, r)
+            item = make.circle(x0, y0, x1, y1)
+        elif shape == ContourShape.ELLIPSE:
+            xc, yc, a, b, theta = shapeargs
+            coords_ellipse = coordinates.ellipse_to_diameters(xc, yc, a, b, theta)
+            x0, y0, x1, y1, x2, y2, x3, y3 = coords_ellipse
+            item = make.ellipse(x0, y0, x1, y1, x2, y2, x3, y3)
+        else:  # ContourShape.POLYGON
+            # `shapeargs` is a flattened array of x, y coordinates
+            x, y = shapeargs[::2], shapeargs[1::2]
+            item = make.polygon(x, y, closed=False)
+        items.append(item)
+    return items
+
+
+@pytest.mark.gui
+def test_contour_interactive():
+    """2D peak detection test"""
+    data, _coords = get_peak2d_data()
+    with guiutils.lazy_qt_app_context(force=True):
+        # pylint: disable=import-outside-toplevel
+        from plotpy.builder import make
+
+        from sigima.tests import vistools
+
+        items = [make.image(data, interpolation="linear", colormap="hsv")]
+        t0 = time.time()
+        peak_coords = get_2d_peaks_coords(data)
+        dt = time.time() - t0
+        for x, y in peak_coords:
+            items.append(make.marker((x, y)))
+        execenv.print(f"Calculation time: {int(dt * 1e3):d} ms\n", file=sys.stderr)
+        execenv.print(f"Peak coordinates: {peak_coords}")
+
+        # Add contour shapes for all shape types
+        for shape in ContourShape:
+            items.extend(create_contour_shape_items(data, shape))
+
+        vistools.view_image_items(items)
+
+
+@pytest.mark.validation
+def test_contour_shape() -> None:
+    """Test contour shape computation function"""
+    # Create test data with known shapes
+    data, _expected_coords = get_peak2d_data()
+
+    # Test each contour shape type
+    for shape in ContourShape:
+        execenv.print(f"Testing contour shape: {shape}")
+
+        # Get contour shapes from the function
+        detected_shapes = get_contour_shapes(data, shape=shape)
+        execenv.print(f"Detected {len(detected_shapes)} {shape}(s)")
+
+        # Basic validation checks
+        assert isinstance(detected_shapes, np.ndarray), (
+            f"get_contour_shapes should return numpy array for {shape}"
+        )
+
+        if len(detected_shapes) > 0:
+            # Check that we detected at least some shapes
+            execenv.print(f"Successfully detected contours for {shape}")
+
+            # Validate shape-specific properties
+            if shape == ContourShape.CIRCLE:
+                # For circles: [xc, yc, r]
+                assert detected_shapes.shape[1] == 3, (
+                    "Circle contours should have 3 parameters (xc, yc, r)"
+                )
+                # Check that radius values are positive
+                radii = detected_shapes[:, 2]
+                assert np.all(radii > 0), "All circle radii should be positive"
+                check_scalar_result(
+                    "Circle radius range",
+                    np.mean(radii),
+                    np.mean(radii),  # Just check it's finite
+                    rtol=1.0,
+                )
+
+            elif shape == ContourShape.ELLIPSE:
+                # For ellipses: [xc, yc, a, b, theta]
+                assert detected_shapes.shape[1] == 5, (
+                    "Ellipse contours should have 5 parameters (xc, yc, a, b, theta)"
+                )
+                # Check that semi-axes are positive
+                a_values = detected_shapes[:, 2]
+                b_values = detected_shapes[:, 3]
+                assert np.all(a_values > 0), (
+                    "All ellipse semi-axes 'a' should be positive"
+                )
+                assert np.all(b_values > 0), (
+                    "All ellipse semi-axes 'b' should be positive"
+                )
+                check_scalar_result(
+                    "Ellipse semi-axis 'a' range",
+                    np.mean(a_values),
+                    np.mean(a_values),  # Just check it's finite
+                    rtol=1.0,
+                )
+
+            elif shape == ContourShape.POLYGON:
+                # For polygons: flattened x,y coordinates
+                # Shape should be (n_contours, max_points) where max_points is even
+                assert detected_shapes.shape[1] % 2 == 0, (
+                    "Polygon contours should have even number of coordinates "
+                    "(x,y pairs)"
+                )
+                # Check that we have valid coordinates (not all NaN)
+                valid_coords = ~np.isnan(detected_shapes)
+                assert np.any(valid_coords), (
+                    "Polygon should have some valid coordinates"
+                )
+
+        # Check that the function handles different threshold levels
+        for level in [0.3, 0.5, 0.7]:
+            shapes_at_level = get_contour_shapes(data, shape=shape, level=level)
+            assert isinstance(shapes_at_level, np.ndarray), (
+                f"get_contour_shapes should return numpy array for {shape} "
+                f"at level {level}"
+            )
+            execenv.print(f"  At level {level}: detected {len(shapes_at_level)} shapes")
+
+    execenv.print("All contour shape tests passed!")
+
+
+if __name__ == "__main__":
+    test_contour_interactive()
+    test_contour_shape()

sigima/tests/image/convolution_unit_test.py

@@ -0,0 +1,178 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""Unit tests for image convolution/deconvolution features."""
+
+from __future__ import annotations
+
+from contextlib import contextmanager
+
+import numpy as np
+import pytest
+import scipy.signal as sps
+
+from sigima.config import options as sigima_options
+from sigima.objects import create_image, create_image_from_param
+from sigima.objects.image import Gauss2DParam, ImageObj, Zero2DParam
+from sigima.proc.image.mathops import convolution, deconvolution
+from sigima.tests import guiutils
+from sigima.tests.helpers import check_array_result
+from sigima.tools.image import deconvolve
+
+
+@contextmanager
+def disable_kernel_normalization():
+    """Context manager to temporarily disable kernel normalization."""
+    # Save current values
+    original_auto_normalize = sigima_options.auto_normalize_kernel.get()
+
+    # Disable for test
+    sigima_options.auto_normalize_kernel.set(False)
+
+    try:
+        yield
+    finally:
+        # Restore original values
+        sigima_options.auto_normalize_kernel.set(original_auto_normalize)
+
+
+def _generate_rectangle_image(title: str = "Rectangle", size: int = 32) -> ImageObj:
+    """Generate a test square image with a rectangle in the center."""
+    data = np.zeros((size, size), dtype=np.float64)
+    data[size // 5 : 2 * size // 5, size // 7 : 5 * size // 7] = 1.0
+    img = create_image(title, data)
+    return img
+
+
+def _generate_image(size: int = 32) -> ImageObj:
+    """Generate a test square image.
+
+    Args:
+        size: The dimension of the square image to generate.
+
+    Returns:
+        An image object.
+    """
+    # Gaussian image.
+    gauss_img = create_image_from_param(Gauss2DParam.create(height=size, width=size))
+    return gauss_img
+
+
+def _generate_gaussian_kernel(size: int = 32, sigma: float = 1.0) -> ImageObj:
+    """Generate a Gaussian kernel image.
+
+    Args:
+        size: The dimension of the square kernel to generate.
+        sigma: The standard deviation of the Gaussian.
+
+    Returns:
+        An image object.
+    """
+    kernel = create_image_from_param(
+        Gauss2DParam.create(height=size, width=size, sigma=sigma)
+    )
+    return kernel
+
+
+def _generate_identity_kernel(size: int = 7) -> ImageObj:
+    """Generate an identity kernel image.
+
+    Args:
+        size: The dimension of the square kernel to generate (must be odd).
+
+    Returns:
+        An image object.
+    """
+    assert size % 2 == 1, "Identity kernel size must be odd."
+    kernel = create_image_from_param(Zero2DParam.create(height=size, width=size))
+    assert kernel.data is not None
+    kernel.data[size // 2, size // 2] = 1.0
+    return kernel
+
+
+def __convolve_image(kernel: ImageObj, size: int = 32) -> tuple[ImageObj, ImageObj]:
+    """Generate a test image and its convolution with a Gaussian kernel.
+
+    Returns:
+        A tuple (source image, kernel, convolved image).
+    """
+    original = _generate_rectangle_image(size=size)
+    assert original.data is not None
+    convolved = convolution(original, kernel)
+    assert convolved.data is not None
+    return original, convolved
+
+
+@pytest.mark.validation
+def test_image_convolution(size: int = 32) -> None:
+    """Validation test for the image convolution processing.
+
+    Note: This test disables kernel normalization to compare against raw scipy results.
+    """
+    with disable_kernel_normalization():
+        # Test with a Gaussian kernel.
+        kernel = _generate_gaussian_kernel(size=size, sigma=1.0)
+        original, convolved = __convolve_image(kernel, size=size)
+        exp = sps.convolve(original.data, kernel.data, mode="same", method="auto")
+        check_array_result("Convolution", convolved.data, exp)
+        guiutils.view_images_side_by_side_if_gui(
+            [original, kernel, convolved],
+            ["Original", "Kernel", "Convolved"],
+            title="Image Convolution Test: Gaussian Kernel",
+        )
+        # Test with an identity kernel.
+        kernel = _generate_identity_kernel(size=7)
+        original, convolved = __convolve_image(kernel, size=size)
+        # check_array_result("Convolution identity", convolved.data, original.data)
+        guiutils.view_images_side_by_side_if_gui(
+            [original, kernel, convolved],
+            ["Original", "Kernel", "Convolved"],
+            title="Image Convolution Test: Identity Kernel",
+        )
+
+
+@pytest.mark.validation
+def test_image_deconvolution(size: int = 32) -> None:
+    """Validation test for image deconvolution.
+
+    Note: This test disables kernel normalization to compare against expected results.
+    """
+    with disable_kernel_normalization():
+        # Test with an identity kernel.
+        kernel = _generate_identity_kernel(size=31)
+        original, convolved = __convolve_image(kernel, size=size)
+        deconvolved = deconvolution(convolved, kernel)
+        guiutils.view_images_side_by_side_if_gui(
+            [original, kernel, convolved, deconvolved],
+            ["Original", "Kernel", "Convolved", "Deconvolved"],
+            title="Image Deconvolution Test: Identity Kernel",
+        )
+        check_array_result("Deconvolution identity", deconvolved.data, original.data)
+
+        # # Test with a Gaussian kernel.
+        kernel = _generate_gaussian_kernel(size=31, sigma=1.0)
+        original, convolved = __convolve_image(kernel, size=64)
+        deconvolved = deconvolution(convolved, kernel)
+        # check_array_result("Deconvolution Gaussian", deconvolved.data, original.data)
+        guiutils.view_images_side_by_side_if_gui(
+            [original, kernel, convolved, deconvolved],
+            ["Original", "Kernel", "Convolved", "Deconvolved"],
+            title="Image Deconvolution Test: Gaussian Kernel",
+        )
+
+
+def test_tools_image_deconvolve_null_kernel() -> None:
+    """Test deconvolution with a null kernel."""
+    size = 32
+    src = _generate_image(size)
+    assert src.data is not None
+    kernel = create_image_from_param(Zero2DParam.create(height=size, width=size))
+    assert kernel.data is not None
+    with pytest.raises(ValueError, match="Deconvolution kernel cannot be null."):
+        deconvolve(src.data, kernel.data)
+
+
+if __name__ == "__main__":
+    guiutils.enable_gui()
+    test_image_convolution()
+    test_image_deconvolution()
+    test_tools_image_deconvolve_null_kernel()

sigima/tests/image/datatype_unit_test.py

@@ -0,0 +1,67 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Unit tests for image data types
+-------------------------------
+
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+
+from __future__ import annotations
+
+import numpy as np
+
+from sigima.objects import ImageDatatypes
+from sigima.tests.env import execenv
+from sigima.tools.datatypes import clip_astype
+
+
+def get_integer_datatypes() -> list[ImageDatatypes]:
+    """Return all integer data types."""
+    return [dtype for dtype in ImageDatatypes if "int" in dtype.name.lower()]
+
+
+def test_clip_astype():
+    """Test `clip_astype` algorithm"""
+    # Test that function do nothing for certain data types
+    for dtype1 in ImageDatatypes:
+        for dtype2 in ImageDatatypes:
+            if not np.issubdtype(dtype2.value, np.integer):
+                continue
+            if np.issubdtype(dtype1.value, np.integer):
+                info1 = np.iinfo(dtype1.value)
+            else:
+                info1 = np.finfo(dtype1.value)
+            info2 = np.iinfo(dtype2.value)
+            if info2.min < info1.min or info2.max > info1.max:
+                continue
+            data = np.array([0, 1, 2, 3, 4, 5], dtype=dtype1.value)
+            txt = f"No change: {dtype1.value} -> {dtype2.value}"
+            execenv.print(txt, end="... ")
+            assert np.array_equal(clip_astype(data, dtype2.value), data), txt
+            execenv.print("OK")
+
+    # Test that function handles overflow for integer data types
+    for dtype in get_integer_datatypes():
+        maxval = np.iinfo(dtype.value).max
+        data1 = np.array([maxval], dtype=dtype.value)
+        data2 = clip_astype(data1.astype(float) + 1, dtype.value)
+        txt = f"Overflow: {dtype.value}"
+        execenv.print(txt, end="... ")
+        assert data2[0] == maxval, txt
+        execenv.print("OK")
+
+    # Test that function handles underflow for integer data types
+    for dtype in get_integer_datatypes():
+        minval = np.iinfo(dtype.value).min
+        data1 = np.array([minval], dtype=dtype.value)
+        data2 = clip_astype(data1.astype(float) - 1, dtype.value)
+        txt = f"Underflow: {dtype.value}"
+        execenv.print(txt, end="... ")
+        assert data2[0] == minval, txt
+        execenv.print("OK")
+
+
+if __name__ == "__main__":
+    test_clip_astype()

sigima/tests/image/edges_unit_test.py

@@ -0,0 +1,155 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Unit tests for edge detection computation functions.
+"""
+
+from __future__ import annotations
+
+import pytest
+from skimage import feature, filters, util
+
+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
+
+
+@pytest.mark.validation
+def test_canny() -> None:
+    """Validation test for the image Canny edge detection processing."""
+    # See [1] in sigima\tests\image\__init__.py for more details about the validation.
+    src = get_test_image("flower.npy")
+    p = sigima.params.CannyParam.create(
+        sigma=1.0, low_threshold=0.1, high_threshold=0.2
+    )
+    dst = sigima.proc.image.canny(src, p)
+    exp = util.img_as_ubyte(
+        feature.canny(
+            src.data,
+            sigma=p.sigma,
+            low_threshold=p.low_threshold,
+            high_threshold=p.high_threshold,
+            use_quantiles=p.use_quantiles,
+            mode=p.mode,
+            cval=p.cval,
+        )
+    )
+    check_array_result(
+        f"Canny[sigma={p.sigma},low_threshold={p.low_threshold},"
+        f"high_threshold={p.high_threshold}]",
+        dst.data,
+        exp,
+    )
+
+
+def __generic_edge_validation(method: str) -> None:
+    """Generic test for edge detection methods."""
+    # See [1] in sigima\tests\image\__init__.py for more details about the validation.
+    src = get_test_image("flower.npy")
+    dst: sigima.objects.ImageObj = getattr(sigima.proc.image, method)(src)
+    exp = getattr(filters, method)(src.data)
+    check_array_result(f"{method.capitalize()}", dst.data, exp)
+
+
+@pytest.mark.validation
+def test_roberts() -> None:
+    """Validation test for the image Roberts edge detection processing."""
+    __generic_edge_validation("roberts")
+
+
+@pytest.mark.validation
+def test_prewitt() -> None:
+    """Validation test for the image Prewitt edge detection processing."""
+    __generic_edge_validation("prewitt")
+
+
+@pytest.mark.validation
+def test_prewitt_h() -> None:
+    """Validation test for the image horizontal Prewitt edge detection processing."""
+    __generic_edge_validation("prewitt_h")
+
+
+@pytest.mark.validation
+def test_prewitt_v() -> None:
+    """Validation test for the image vertical Prewitt edge detection processing."""
+    __generic_edge_validation("prewitt_v")
+
+
+@pytest.mark.validation
+def test_sobel() -> None:
+    """Validation test for the image Sobel edge detection processing."""
+    __generic_edge_validation("sobel")
+
+
+@pytest.mark.validation
+def test_sobel_h() -> None:
+    """Validation test for the image horizontal Sobel edge detection processing."""
+    __generic_edge_validation("sobel_h")
+
+
+@pytest.mark.validation
+def test_sobel_v() -> None:
+    """Validation test for the image vertical Sobel edge detection processing."""
+    __generic_edge_validation("sobel_v")
+
+
+@pytest.mark.validation
+def test_scharr() -> None:
+    """Validation test for the image Scharr edge detection processing."""
+    __generic_edge_validation("scharr")
+
+
+@pytest.mark.validation
+def test_scharr_h() -> None:
+    """Validation test for the image horizontal Scharr edge detection processing."""
+    __generic_edge_validation("scharr_h")
+
+
+@pytest.mark.validation
+def test_scharr_v() -> None:
+    """Validation test for the image vertical Scharr edge detection processing."""
+    __generic_edge_validation("scharr_v")
+
+
+@pytest.mark.validation
+def test_farid() -> None:
+    """Validation test for the image Farid edge detection processing."""
+    __generic_edge_validation("farid")
+
+
+@pytest.mark.validation
+def test_farid_h() -> None:
+    """Validation test for the image horizontal Farid edge detection processing."""
+    __generic_edge_validation("farid_h")
+
+
+@pytest.mark.validation
+def test_farid_v() -> None:
+    """Validation test for the image vertical Farid edge detection processing."""
+    __generic_edge_validation("farid_v")
+
+
+@pytest.mark.validation
+def test_laplace() -> None:
+    """Validation test for the image Laplace edge detection processing."""
+    __generic_edge_validation("laplace")
+
+
+if __name__ == "__main__":
+    test_canny()
+    test_roberts()
+    test_prewitt()
+    test_prewitt_h()
+    test_prewitt_v()
+    test_sobel()
+    test_sobel_h()
+    test_sobel_v()
+    test_scharr()
+    test_scharr_h()
+    test_scharr_v()
+    test_farid()
+    test_farid_h()
+    test_farid_v()
+    test_laplace()

sigima/tests/image/enclosingcircle_unit_test.py

@@ -0,0 +1,88 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Enclosing circle test
+
+Testing enclsoing circle function on various test images.
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# pylint: disable=duplicate-code
+
+import pytest
+
+import sigima.tools.image
+from sigima.config import _
+from sigima.proc.image import enclosing_circle
+from sigima.tests import guiutils
+from sigima.tests.data import RingParam, create_ring_image, get_laser_spot_data
+from sigima.tests.env import execenv
+from sigima.tests.helpers import check_scalar_result
+
+
+def __enclosingcircle_test(data):
+    """Enclosing circle test function"""
+    # pylint: disable=import-outside-toplevel
+    from plotpy.builder import make
+
+    from sigima.tests import vistools
+
+    items = []
+    items += [make.image(data, interpolation="nearest", eliminate_outliers=1.0)]
+
+    # Computing centroid coordinates
+    row, col = sigima.tools.image.get_centroid_auto(data)
+    label = _("Centroid") + " (%d, %d)"
+    execenv.print(label % (row, col))
+    cursor = make.xcursor(col, row, label=label)
+    cursor.set_resizable(False)
+    cursor.set_movable(False)
+    items.append(cursor)
+
+    x, y, radius = sigima.tools.image.get_enclosing_circle(data)
+    circle = make.circle(x - radius, y - radius, x + radius, y + radius)
+    circle.set_readonly(True)
+    circle.set_resizable(False)
+    circle.set_movable(False)
+    items.append(circle)
+    execenv.print(x, y, radius)
+    execenv.print("")
+
+    vistools.view_image_items(items)
+
+
+@pytest.mark.gui
+def test_enclosing_circle_interactive():
+    """Interactive test for enclosing circle computation."""
+    with guiutils.lazy_qt_app_context(force=True):
+        for data in get_laser_spot_data():
+            __enclosingcircle_test(data)
+
+
+@pytest.mark.validation
+def test_image_enclosing_circle():
+    """Test enclosing circle on a ring image."""
+    p = RingParam.create(
+        image_size=200,
+        xc=100,
+        yc=100,
+        radius=30,
+        thickness=5,
+    )
+    # Create a ring image, so that the outer circle radius is radius + thickness:
+    obj = create_ring_image(p)
+    execenv.print("Testing enclosing circle on a ring image...")
+    ex, ey, er = sigima.tools.image.get_enclosing_circle(obj.data)
+    geometry = enclosing_circle(obj)
+    x, y, r = geometry.coords[0]
+    execenv.print(geometry)
+    assert ex == x and ey == y and er == r, (
+        f"Enclosing circle test failed: expected ({ex}, {ey}, {er}), "
+        f"got ({x}, {y}, {r})"
+    )
+    check_scalar_result("Enclosing circle", er, p.radius + p.thickness, rtol=0.002)
+
+
+if __name__ == "__main__":
+    test_enclosing_circle_interactive()
+    test_image_enclosing_circle()