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

sigima/tests/image/roi_grid_unit_test.py

@@ -0,0 +1,279 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""Image grid ROI unit tests"""
+
+from __future__ import annotations
+
+import os.path as osp
+from copy import deepcopy
+
+import guidata.dataset as gds
+import numpy as np
+from numpy.testing import assert_array_equal
+from pytest import approx
+
+from sigima.io import read_roi_grid, write_roi_grid
+from sigima.objects import ImageObj, ImageROI, create_image
+from sigima.proc.image.extraction import (
+    Direction,
+    ROIGridParam,
+    extract_roi,
+    generate_image_grid_roi,
+)
+from sigima.tests.data import create_grid_of_gaussian_images
+from sigima.tests.helpers import WorkdirRestoringTempDir
+
+
+def _roi_by_title(roi: list[ImageROI], title: str) -> ImageROI:
+    """Get ROI by title."""
+    for r in roi:
+        if getattr(r, "title", None) == title:
+            return r
+    raise KeyError(title)
+
+
+def test_roi_grid_basic_geometry() -> None:
+    """2x2 grid, 50% size, centered (50% translations)."""
+    img = create_grid_of_gaussian_images()  # synthetic image with known geometry
+    p = ROIGridParam()
+    p.nx = p.ny = 2
+    p.xsize = p.ysize = 50
+    p.xtranslation = p.ytranslation = 50
+    p.xdirection = p.ydirection = Direction.INCREASING
+    p.base_name = "ROI"
+    p.name_pattern = "{base}({r},{c})"
+
+    # src.roi must stay untouched (pure builder)
+    assert img.roi is None
+
+    roi = generate_image_grid_roi(img, p)
+
+    # 4 rectangles created
+    items = list(roi)
+    assert len(items) == 4
+
+    # Titles present
+    titles = {r.title for r in items}
+    assert {"ROI(1,1)", "ROI(1,2)", "ROI(2,1)", "ROI(2,2)"} <= titles
+
+    # Check one rectangle’s geometry (top-left label)
+    r11 = _roi_by_title(roi, "ROI(1,1)")
+    _x0, _y0, dx, dy = r11.get_physical_coords(img)  # uses indices=False path
+    # Each cell: width/2 by height/2; ROI takes 50% of that
+    assert dx == approx((img.width / 2) * 0.5)
+    assert dy == approx((img.height / 2) * 0.5)
+
+    # Source image must still be unmodified
+    assert img.roi is None
+
+
+def test_labeling_changes_with_direction_but_geometry_set_is_invariant() -> None:
+    """Flipping directions relabels cells
+    but the set of rectangles (geometry) stays the same."""
+    img = create_grid_of_gaussian_images()
+    base = ROIGridParam()
+    base.nx = base.ny = 2
+    base.xsize = base.ysize = 50
+    base.xtranslation = base.ytranslation = 50
+    base.base_name = "ROI"
+    base.name_pattern = "{base}({r},{c})"
+
+    # Increasing both
+    p_inc = deepcopy(base)
+    p_inc.xdirection = p_inc.ydirection = Direction.INCREASING
+    roi_inc = generate_image_grid_roi(img, p_inc)
+    geoms_inc = sorted(
+        (r.get_physical_coords(img) for r in roi_inc), key=lambda t: (t[0], t[1])
+    )
+
+    # Decreasing both
+    p_dec = deepcopy(base)
+    p_dec.xdirection = p_dec.ydirection = Direction.DECREASING
+    roi_dec = generate_image_grid_roi(img, p_dec)
+    geoms_dec = sorted(
+        (r.get_physical_coords(img) for r in roi_dec), key=lambda t: (t[0], t[1])
+    )
+
+    # Same rectangles, just different titles
+    for (x0a, y0a, dxa, dya), (x0b, y0b, dxb, dyb) in zip(geoms_inc, geoms_dec):
+        assert x0a == approx(x0b)
+        assert y0a == approx(y0b)
+        assert dxa == approx(dxb)
+        assert dya == approx(dyb)
+
+
+def test_translation_semantics_delta() -> None:
+    """Changing translation by +10% moves rectangles by 10% of image size."""
+    img = create_grid_of_gaussian_images()
+    p1 = ROIGridParam()
+    p1.nx = p1.ny = 2
+    p1.xsize = p1.ysize = 50
+    p1.xtranslation = p1.ytranslation = 50  # centered
+    p1.xdirection = p1.ydirection = Direction.INCREASING
+
+    p2 = deepcopy(p1)
+    p2.xtranslation = 60  # +10% shift in X
+
+    roi1 = generate_image_grid_roi(img, p1)
+    roi2 = generate_image_grid_roi(img, p2)
+
+    r11_1 = _roi_by_title(roi1, "ROI(1,1)")
+    r11_2 = _roi_by_title(roi2, "ROI(1,1)")
+
+    x0_1, y0_1, dx1, dy1 = r11_1.get_physical_coords(img)
+    x0_2, y0_2, dx2, dy2 = r11_2.get_physical_coords(img)
+
+    # Width should be unchanged; position should shift by exactly 10% of image width
+    assert dx1 == approx(dx2)
+    assert dy1 == approx(dy2)
+    assert (x0_2 - x0_1) == approx(0.10 * img.width)
+    assert (y0_2 - y0_1) == approx(0.00 * img.height)
+
+
+def test_invalid_name_pattern_falls_back() -> None:
+    """Malformed pattern should not break: titles fall back to 'ROI(r,c)'."""
+    img = create_grid_of_gaussian_images()
+    p = ROIGridParam()
+    p.nx = p.ny = 1
+    p.xsize = p.ysize = 50
+    p.xtranslation = p.ytranslation = 50
+    p.xdirection = p.ydirection = Direction.INCREASING
+    p.base_name = "ANY"
+    p.name_pattern = "{this_will_raise}"  # invalid placeholders
+
+    roi = generate_image_grid_roi(img, p)
+    titles = [r.title for r in roi]
+    assert titles == ["ROI(1,1)"]  # see fallback in implementation
+
+
+def test_zero_size_is_allowed_currently() -> None:
+    """Current behavior: 0% sizes produce degenerate rectangles (dx==0 or dy==0)."""
+    img = create_grid_of_gaussian_images()
+    p = ROIGridParam()
+    p.nx = p.ny = 2
+    p.xsize = 0
+    p.ysize = 50
+    p.xtranslation = p.ytranslation = 50
+
+    roi = generate_image_grid_roi(img, p)
+    # All ROIs exist; all have dx == 0
+    for r in roi:
+        _x0, _y0, dx, dy = r.get_physical_coords(img)
+        assert dx == approx(0.0)
+        assert dy > 0.0
+
+
+def _make_positional_image(h=6, w=9, dx=1.0, dy=1.0, x0=0.0, y0=0.0) -> ImageObj:
+    """
+    pixel(y, x) = 1000*y + x  (strictly monotone in both axes)
+    Choosing H=6, W=9 allows clean 2x3 tiling (cell=3x3).
+    """
+    data = np.add.outer(
+        1000 * np.arange(h, dtype=np.int32), np.arange(w, dtype=np.int32)
+    )
+    img = create_image("positional", data)
+    img.set_uniform_coords(dx, dy, x0, y0)
+    img.roi = None
+    return img
+
+
+def test_roi_grid_extract_matches_pattern() -> None:
+    """Test that the extracted ROIs match the expected pattern."""
+    img = _make_positional_image(h=6, w=9)  # 6x9 → ny=2, nx=3 → cells are 3x3
+
+    # Build a full-coverage grid: each ROI == cell (no gaps/overlaps)
+    p = ROIGridParam()
+    p.nx, p.ny = 3, 2
+    p.xsize = p.ysize = 100  # ROI size == cell size
+    p.xtranslation = p.ytranslation = 50  # centered on each cell
+    p.xdirection = p.ydirection = Direction.INCREASING
+    p.base_name = "ROI"
+    p.name_pattern = "{base}({r},{c})"
+
+    roi = generate_image_grid_roi(img, p)  # pure builder, no mutation
+    # Sanity: full coverage, 3*2 cells, all 3x3
+
+    params = roi.to_params(img)
+    for rparam in params:
+        # Reference window from indices
+        x0, y0, x1, y1 = rparam.get_bounding_box_indices(img)
+        ref = img.data[y0:y1, x0:x1]
+
+        # Extract via computation function
+        extracted = extract_roi(img, rparam)
+        out = extracted.data
+
+        # 1) Pixel-exact equality
+        assert_array_equal(out, ref)
+
+        # 2) Dimensions are the expected 3x3
+        assert out.shape == (3, 3)
+
+        # 3) Physical origin is consistent with bounding box (dx=dy=1, x0=y0=0)
+        px0, py0, _px1, _py1 = rparam.get_bounding_box_physical()
+        assert extracted.x0 == px0
+        assert extracted.y0 == py0
+
+
+def test_roi_grid_extract_with_translation() -> None:
+    """Shift the grid by +10% in X (of full image width) and verify that each ROI
+    moves accordingly — the extracted content matches the shifted reference.
+    """
+    img = _make_positional_image(h=6, w=9)  # width=9 → +10% shift = 0.9 pixel
+
+    # Base centered grid (2x3)
+    p1 = ROIGridParam()
+    p1.nx, p1.ny = 3, 2
+    p1.xsize = p1.ysize = 100
+    p1.xtranslation = p1.ytranslation = 50
+    p1.xdirection = p1.ydirection = Direction.INCREASING
+    p1.base_name = "ROI"
+    p1.name_pattern = "{base}({r},{c})"
+
+    # Shifted grid (+10% in X)
+    p2 = deepcopy(p1)
+    p2.xtranslation = 60
+
+    roi1 = generate_image_grid_roi(img, p1)
+    roi2 = generate_image_grid_roi(img, p2)
+
+    # Compare first ROI of each row/col "logically" (same label), but expect
+    # a one-pixel shift when rounding indices. To avoid rounding heuristics,
+    # we compare against each ROI's own bounding box-derived slice.
+    roiparams1, roiparams2 = roi1.to_params(img), roi2.to_params(img)
+    for rp1, rp2 in zip(roiparams1, roiparams2):
+        ref1 = img.data[
+            rp1.get_bounding_box_indices(img)[1] : rp1.get_bounding_box_indices(img)[3],
+            rp1.get_bounding_box_indices(img)[0] : rp1.get_bounding_box_indices(img)[2],
+        ]
+        ref2 = img.data[
+            rp2.get_bounding_box_indices(img)[1] : rp2.get_bounding_box_indices(img)[3],
+            rp2.get_bounding_box_indices(img)[0] : rp2.get_bounding_box_indices(img)[2],
+        ]
+        out1 = extract_roi(img, rp1).data
+        out2 = extract_roi(img, rp2).data
+        # Both extractions must match their own references exactly
+        assert_array_equal(out1, ref1)
+        assert_array_equal(out2, ref2)
+
+
+def test_roi_grid_import_export() -> None:
+    """Test the import and export of ROI grids."""
+    p = ROIGridParam()
+    p.nx, p.ny = 3, 2
+    p.xsize = p.ysize = 100
+    p.xtranslation = p.ytranslation = 50
+    p.xdirection = p.ydirection = Direction.INCREASING
+    p.base_name = "ROI"
+    p.name_pattern = "{base}({r},{c})"
+
+    with WorkdirRestoringTempDir() as temp_dir:
+        path = osp.join(temp_dir, "test_roi_grid.json")
+        write_roi_grid(path, p)
+        new_p = read_roi_grid(path)
+
+    gds.assert_datasets_equal(new_p, p, "Imported ROI grid does not match original")
+
+
+if __name__ == "__main__":
+    test_roi_grid_import_export()

sigima/tests/image/spectrum2d_unit_test.py

@@ -0,0 +1,40 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Image spectrum unit test.
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# pylint: disable=duplicate-code
+
+import pytest
+
+import sigima.tools.image
+from sigima.tests import guiutils
+from sigima.tests.data import get_test_image
+
+
+@pytest.mark.gui
+def test_image_spectrum_interactive():
+    """Interactive test of the magnitude/phase/power spectrum of an image."""
+    with guiutils.lazy_qt_app_context(force=True):
+        # pylint: disable=import-outside-toplevel
+        from sigima.tests.vistools import view_images_side_by_side
+
+        obj = get_test_image("NF 180338201.scor-data")
+        data = obj.data
+        ms = sigima.tools.image.magnitude_spectrum(data, log_scale=True)
+        ps = sigima.tools.image.phase_spectrum(data)
+        psd = sigima.tools.image.psd(data, log_scale=True)
+        images = [data, ms, ps, psd]
+        titles = [
+            "Original",
+            "Magnitude spectrum",
+            "Phase spectrum",
+            "Power spectral density",
+        ]
+        view_images_side_by_side(images, titles, rows=2, title="Image spectrum")
+
+
+if __name__ == "__main__":
+    test_image_spectrum_interactive()

sigima/tests/image/threshold_unit_test.py

@@ -0,0 +1,91 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Unit tests for thresholding computation functions.
+"""
+
+from __future__ import annotations
+
+import pytest
+from skimage import filters, util
+
+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_threshold() -> None:
+    """Validation test for the image threshold processing."""
+    src = get_test_image("flower.npy")
+    p = sigima.params.ThresholdParam.create(value=100.0)
+    dst = sigima.proc.image.threshold(src, p)
+    exp = util.img_as_ubyte(src.data > p.value)
+    check_array_result(f"Threshold[{p.value}]", dst.data, exp)
+
+
+def __generic_threshold_validation(method: str) -> None:
+    """Generic test for thresholding methods."""
+    # See [1] in sigima\tests\image\__init__.py for more details about the validation.
+    src = get_test_image("flower.npy")
+    dst = sigima.proc.image.threshold(
+        src, sigima.params.ThresholdParam.create(method=method)
+    )
+    exp = util.img_as_ubyte(
+        src.data > getattr(filters, f"threshold_{method}")(src.data)
+    )
+    check_array_result(f"Threshold{method.capitalize()}", dst.data, exp)
+
+
+@pytest.mark.validation
+def test_threshold_isodata() -> None:
+    """Validation test for the image threshold Isodata processing."""
+    __generic_threshold_validation("isodata")
+
+
+@pytest.mark.validation
+def test_threshold_li() -> None:
+    """Validation test for the image threshold Li processing."""
+    __generic_threshold_validation("li")
+
+
+@pytest.mark.validation
+def test_threshold_mean() -> None:
+    """Validation test for the image threshold Mean processing."""
+    __generic_threshold_validation("mean")
+
+
+@pytest.mark.validation
+def test_threshold_minimum() -> None:
+    """Validation test for the image threshold Minimum processing."""
+    __generic_threshold_validation("minimum")
+
+
+@pytest.mark.validation
+def test_threshold_otsu() -> None:
+    """Validation test for the image threshold Otsu processing."""
+    __generic_threshold_validation("otsu")
+
+
+@pytest.mark.validation
+def test_threshold_triangle() -> None:
+    """Validation test for the image threshold Triangle processing."""
+    __generic_threshold_validation("triangle")
+
+
+@pytest.mark.validation
+def test_threshold_yen() -> None:
+    """Validation test for the image threshold Yen processing."""
+    __generic_threshold_validation("yen")
+
+
+if __name__ == "__main__":
+    test_threshold()
+    test_threshold_isodata()
+    test_threshold_li()
+    test_threshold_mean()
+    test_threshold_minimum()
+    test_threshold_otsu()
+    test_threshold_triangle()
+    test_threshold_yen()

sigima/tests/io/addnewformat_unit_test.py

@@ -0,0 +1,125 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Test adding new I/O formats
+"""
+
+from __future__ import annotations
+
+from typing import Type
+
+import numpy as np
+
+from sigima.io import ImageIORegistry, SignalIORegistry
+from sigima.io.base import FormatInfo
+from sigima.io.image.base import SingleImageFormatBase
+from sigima.io.signal.base import SignalFormatBase
+from sigima.tests.env import execenv
+
+
+def _get_image_format_number() -> int:
+    """Get the number of standard image formats"""
+    return len(ImageIORegistry.get_formats())
+
+
+def _add_image_format() -> Type[SingleImageFormatBase]:
+    """Add a new image format to the registry"""
+
+    class MyImageFormat(SingleImageFormatBase):
+        """Object representing MyImageFormat image file type"""
+
+        FORMAT_INFO = FormatInfo(
+            name="MyImageFormat",
+            extensions="*.myimg",
+            readable=True,
+            writeable=False,
+        )
+
+        @staticmethod
+        def read_data(filename: str) -> np.ndarray:
+            """Read data and return it
+
+            Args:
+                filename (str): path to MyImageFormat file
+
+            Returns:
+                np.ndarray: image data
+            """
+            # Implement reading logic here
+
+    return MyImageFormat
+
+
+def test_add_image_format() -> None:
+    """Test adding a new image format"""
+    n1 = _get_image_format_number()
+    execenv.print(f"Number of standard image formats: {n1}")
+    execenv.print("Adding MyImageFormat... ", end="")
+    image_class = _add_image_format()
+    n2 = _get_image_format_number()
+    assert n2 == n1 + 1, "Image format was not added correctly"
+    execenv.print("OK")
+    execenv.print(f"New number of image formats:      {n2}")
+    assert (
+        sum(isinstance(fmt, image_class) for fmt in ImageIORegistry.get_formats()) == 1
+    )
+    finfo = image_class.FORMAT_INFO
+    finfo_str = "\n".join([(" " * 4) + line for line in str(finfo).splitlines()])
+    assert finfo_str in ImageIORegistry.get_format_info(mode="text")
+
+
+def _get_signal_format_number() -> int:
+    """Get the number of standard signal formats"""
+    return len(SignalIORegistry.get_formats())
+
+
+def _add_signal_format() -> Type[SignalFormatBase]:
+    """Add a new signal format to the registry"""
+
+    class MySignalFormat(SignalFormatBase):
+        """Object representing MySignalFormat signal file type"""
+
+        FORMAT_INFO = FormatInfo(
+            name="MySignalFormat",
+            extensions="*.mysig",
+            readable=True,
+            writeable=False,
+        )
+
+        def read_xydata(self, filename: str) -> np.ndarray:
+            """Read data and metadata from file, write metadata to object, return xydata
+
+            Args:
+                filename: Name of file to read
+
+            Returns:
+                NumPy array xydata
+            """
+            # Implement reading logic here
+            print(f"Reading data from {filename}")
+
+    return MySignalFormat
+
+
+def test_add_signal_format() -> None:
+    """Test adding a new signal format"""
+    n1 = _get_signal_format_number()
+    execenv.print(f"Number of standard signal formats: {n1}")
+    execenv.print("Adding MySignalFormat... ", end="")
+    signal_class = _add_signal_format()
+    n2 = _get_signal_format_number()
+    assert n2 == n1 + 1, "Signal format was not added correctly"
+    execenv.print("OK")
+    execenv.print(f"New number of signal formats:      {n2}")
+    assert (
+        sum(isinstance(fmt, signal_class) for fmt in SignalIORegistry.get_formats())
+        == 1
+    )
+    finfo = signal_class.FORMAT_INFO
+    finfo_str = "\n".join([(" " * 4) + line for line in str(finfo).splitlines()])
+    assert finfo_str in SignalIORegistry.get_format_info(mode="text")
+
+
+if __name__ == "__main__":
+    test_add_image_format()
+    test_add_signal_format()