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

sigima/tests/common/roi_geometry_unit_test.py

@@ -0,0 +1,171 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""Test ROI geometry transformations"""
+
+import numpy as np
+
+from sigima.objects.image import ImageObj, ImageROI, RectangularROI
+from sigima.proc.image import fliph, flipv, rotate90, rotate270, transpose
+from sigima.tests.env import execenv
+
+
+def test_roi_rotate90() -> None:
+    """Test ROI transformation with 90° rotation."""
+    # Create test image
+    data = np.random.rand(100, 80)  # Height=100, Width=80
+    img = ImageObj(title="Test Image")
+    img.data = data
+
+    # Create rectangular ROI
+    roi_obj = ImageROI()
+    single_roi = RectangularROI([10, 20, 20, 20], indices=False)  # x0, y0, dx, dy
+    roi_obj.add_roi(single_roi)
+    img.roi = roi_obj
+
+    # Apply rotation
+    img_rotated = rotate90(img)
+    roi_rotated = img_rotated.roi.single_rois[0]
+
+    # Verify ROI is properly transformed and dimensions change
+    assert img_rotated.roi is not None, "90° rotation should preserve ROI object"
+    assert len(img_rotated.roi.single_rois) == 1, (
+        "90° rotation should preserve ROI count"
+    )
+
+    # The exact coordinates depend on the transformation, but the ROI should be valid
+    coords_rotated = roi_rotated.get_physical_coords(img_rotated)
+    assert len(coords_rotated) == 4, "Rectangular ROI should have 4 coordinates"
+
+
+def test_roi_rotate270() -> None:
+    """Test ROI transformation with 270° rotation."""
+    # Create test image
+    data = np.random.rand(100, 80)
+    img = ImageObj(title="Test Image")
+    img.data = data
+
+    # Create rectangular ROI
+    roi_obj = ImageROI()
+    single_roi = RectangularROI([10, 20, 20, 20], indices=False)
+    roi_obj.add_roi(single_roi)
+    img.roi = roi_obj
+
+    # Apply rotation
+    img_rotated = rotate270(img)
+
+    # Verify ROI is properly transformed
+    assert img_rotated.roi is not None, "270° rotation should preserve ROI object"
+    assert len(img_rotated.roi.single_rois) == 1, (
+        "270° rotation should preserve ROI count"
+    )
+
+
+def test_roi_fliph() -> None:
+    """Test ROI transformation with horizontal flip."""
+    # Create test image
+    data = np.random.rand(100, 80)
+    img = ImageObj(title="Test Image")
+    img.data = data
+
+    # Create rectangular ROI
+    roi_obj = ImageROI()
+    single_roi = RectangularROI([10, 20, 20, 20], indices=False)
+    roi_obj.add_roi(single_roi)
+    img.roi = roi_obj
+
+    # Apply flip
+    img_flipped = fliph(img)
+
+    # Verify ROI is properly transformed
+    assert img_flipped.roi is not None, "Horizontal flip should preserve ROI object"
+    assert len(img_flipped.roi.single_rois) == 1, (
+        "Horizontal flip should preserve ROI count"
+    )
+
+
+def test_roi_flipv() -> None:
+    """Test ROI transformation with vertical flip."""
+    # Create test image
+    data = np.random.rand(100, 80)
+    img = ImageObj(title="Test Image")
+    img.data = data
+
+    # Create rectangular ROI
+    roi_obj = ImageROI()
+    single_roi = RectangularROI([10, 20, 20, 20], indices=False)
+    roi_obj.add_roi(single_roi)
+    img.roi = roi_obj
+
+    # Apply flip
+    img_flipped = flipv(img)
+
+    # Verify ROI is properly transformed
+    assert img_flipped.roi is not None, "Vertical flip should preserve ROI object"
+    assert len(img_flipped.roi.single_rois) == 1, (
+        "Vertical flip should preserve ROI count"
+    )
+
+
+def test_roi_transpose() -> None:
+    """Test ROI transformation with transpose."""
+    # Create test image
+    data = np.random.rand(100, 80)
+    img = ImageObj(title="Test Image")
+    img.data = data
+
+    # Create rectangular ROI
+    roi_obj = ImageROI()
+    single_roi = RectangularROI([10, 20, 20, 20], indices=False)
+    roi_obj.add_roi(single_roi)
+    img.roi = roi_obj
+
+    # Apply transpose
+    img_transposed = transpose(img)
+
+    # Verify ROI is properly transformed
+    assert img_transposed.roi is not None, "Transpose should preserve ROI object"
+    assert len(img_transposed.roi.single_rois) == 1, (
+        "Transpose should preserve ROI count"
+    )
+
+
+def test_roi_comprehensive() -> None:
+    """Comprehensive test for all ROI transformations."""
+    execenv.print("Testing ROI geometry transformations:")
+
+    # Create test image
+    data = np.random.rand(100, 80)  # Height=100, Width=80
+    img = ImageObj(title="Test Image")
+    img.data = data
+
+    # Create rectangular ROI
+    roi_obj = ImageROI()
+    single_roi = RectangularROI([10, 20, 20, 20], indices=False)
+    roi_obj.add_roi(single_roi)
+    img.roi = roi_obj
+
+    coords_original = single_roi.get_physical_coords(img)
+    execenv.print(f"  Original ROI: {coords_original}")
+
+    # Test all transformations
+    transformations = [
+        (rotate90, "rotate90"),
+        (rotate270, "rotate270"),
+        (fliph, "fliph"),
+        (flipv, "flipv"),
+        (transpose, "transpose"),
+    ]
+
+    for transform_func, name in transformations:
+        img_transformed = transform_func(img)
+        roi_transformed = img_transformed.roi.single_rois[0]
+        coords_transformed = roi_transformed.get_physical_coords(img_transformed)
+        execenv.print(f"  {name}: {coords_transformed}")
+
+        # Verify ROI is properly transformed
+        assert img_transformed.roi is not None, f"{name} should preserve ROI object"
+        assert len(img_transformed.roi.single_rois) == 1, (
+            f"{name} should preserve ROI count"
+        )
+
+    execenv.print("  ✅ All ROI transformations working correctly")

sigima/tests/common/scalar_builder_unit_test.py

@@ -0,0 +1,142 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Unit tests for TableResultBuilder (sigima.objects.scalar).
+"""
+
+from numpy import ma
+
+from sigima.objects.scalar import TableResultBuilder
+from sigima.objects.signal import SignalObj
+from sigima.tests.data import create_paracetamol_signal, create_test_signal_rois
+
+
+def create_dummy_signal() -> SignalObj:
+    """Create a simple SignalObj with a single ROI."""
+    sig = create_paracetamol_signal()
+    roi = list(create_test_signal_rois(sig))[0]
+    sig.roi = roi
+    return sig
+
+
+class TestTableResultBuilder:
+    """Test class for TableResultBuilder basic functionality."""
+
+    def test_basic_functionality(self) -> None:
+        """Test basic TableResultBuilder API with a SignalObj."""
+        sig = create_dummy_signal()
+
+        builder = TableResultBuilder("Signal Stats")
+        builder.add(ma.min, "min")
+        builder.add(ma.max, "max")
+        builder.add(ma.mean, "mean")
+
+        table = builder.compute(sig)
+
+        assert table.title == "Signal Stats"
+        # [None, ROI_0] x 3 stats
+        assert len(table.data) == 2 and len(table.data[0]) == 3
+        assert list(table.headers) == ["min", "max", "mean"]
+        assert table.roi_indices[0] == -1  # NO_ROI
+        assert table.roi_indices[1] == 0
+
+        # Check actual values
+        row_none = table.data[0]
+        row_roi = table.data[1]
+        assert isinstance(row_none[0], float)
+        assert isinstance(row_roi[1], float)
+
+
+class TestTableResultBuilderHideColumns:
+    """Test class for TableResultBuilder hide_columns functionality."""
+
+    def setup_method(self) -> None:
+        """Set up test data for each test method."""
+        # pylint: disable=attribute-defined-outside-init
+        self.sig = create_dummy_signal()
+
+    def _create_basic_builder(self) -> TableResultBuilder:
+        """Helper method to create a basic builder with standard columns."""
+        builder = TableResultBuilder("Signal Stats")
+        builder.add(ma.min, "min")
+        builder.add(ma.max, "max")
+        builder.add(ma.mean, "mean")
+        builder.add(ma.std, "std")
+        return builder
+
+    def _assert_display_preferences(
+        self, table, expected_prefs: dict[str, bool]
+    ) -> None:
+        """Helper method to check display preferences and visible headers."""
+        prefs = table.get_display_preferences()
+        assert prefs == expected_prefs
+
+        expected_visible = [name for name, visible in expected_prefs.items() if visible]
+        visible_headers = table.get_visible_headers()
+        assert set(visible_headers) == set(expected_visible)
+
+    def test_hide_some_columns(self) -> None:
+        """Test hiding some columns."""
+        builder = self._create_basic_builder()
+        builder.hide_columns(["max", "std"])
+
+        table = builder.compute(self.sig)
+
+        assert table.title == "Signal Stats"
+        # All headers still present
+        assert list(table.headers) == ["min", "max", "mean", "std"]
+
+        self._assert_display_preferences(
+            table, {"min": True, "max": False, "mean": True, "std": False}
+        )
+
+    def test_hide_nonexistent_columns(self) -> None:
+        """Test hiding non-existent columns."""
+        builder = TableResultBuilder("Signal Stats")
+        builder.add(ma.min, "min")
+        builder.add(ma.max, "max")
+
+        # Try to hide non-existent column - should not cause error
+        builder.hide_columns(["nonexistent", "min"])
+
+        table = builder.compute(self.sig)
+
+        self._assert_display_preferences(table, {"min": False, "max": True})
+
+    def test_hide_empty_list(self) -> None:
+        """Test hiding empty list of columns."""
+        builder = TableResultBuilder("Signal Stats")
+        builder.add(ma.min, "min")
+        builder.add(ma.max, "max")
+
+        builder.hide_columns([])
+
+        table = builder.compute(self.sig)
+
+        self._assert_display_preferences(table, {"min": True, "max": True})
+
+    def test_hide_multiple_calls(self) -> None:
+        """Test multiple hide_columns calls accumulate."""
+        builder = self._create_basic_builder()
+
+        # Hide columns in multiple calls
+        builder.hide_columns(["max"])
+        builder.hide_columns(["std"])
+
+        table = builder.compute(self.sig)
+
+        self._assert_display_preferences(
+            table, {"min": True, "max": False, "mean": True, "std": False}
+        )
+
+    def test_hide_all_columns(self) -> None:
+        """Test hiding all columns."""
+        builder = TableResultBuilder("Signal Stats")
+        builder.add(ma.min, "min")
+        builder.add(ma.max, "max")
+
+        builder.hide_columns(["min", "max"])
+
+        table = builder.compute(self.sig)
+
+        self._assert_display_preferences(table, {"min": False, "max": False})