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

sigima/tests/common/tools_coordinates_unit_test.py

@@ -0,0 +1,60 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Unit tests for :py:mod:`sigima.tools.coordinates`.
+
+This module verifies the correctness of coordinate conversion functions.
+"""
+
+import numpy as np
+import pytest
+
+from sigima.tests.helpers import check_array_result
+from sigima.tools.coordinates import polar_to_complex
+
+polar_to_complex_parameters = [
+    (
+        np.array([1.0, 2.0, 3.0]),
+        np.array([0.0, 90.0, 180.0]),
+        "°",
+        np.array([1 + 0j, 0 + 2j, -3 + 0j]),
+    ),
+    (
+        np.array([1.0, 2.0, 3.0]),
+        np.array([0.0, np.pi / 2, np.pi]),
+        "rad",
+        np.array([1 + 0j, 0 + 2j, -3 + 0j]),
+    ),
+]
+
+
+@pytest.mark.parametrize("r, theta, unit, expected", polar_to_complex_parameters)
+def test_polar_to_complex(r, theta, unit, expected):
+    """Test :py:func:`sigima.tools.polar_to_complex` with valid input.
+
+    Args:
+        r: The radial coordinates.
+        theta: The angular coordinates.
+        unit: The unit of the angular coordinates ("°" or "rad").
+        expected: The expected complex coordinates.
+    """
+    z = polar_to_complex(r, theta, unit=unit)
+    check_array_result(f"polar_to_complex_{unit}", z, expected)
+
+
+def test_polar_to_complex_invalid_unit():
+    """Test :py:func:`sigima.tools.polar_to_complex` with invalid unit.
+
+    Ensure :py:func:`sigima.tools.polar_to_complex` raises ValueError for unsupported
+    unit.
+    """
+    r = np.array([1.0])
+    theta = np.array([0.0])
+    with pytest.raises(ValueError):
+        polar_to_complex(r, theta, unit="foo")
+
+
+if __name__ == "__main__":
+    for parameters in polar_to_complex_parameters:
+        test_polar_to_complex(*parameters)
+    test_polar_to_complex_invalid_unit()

sigima/tests/common/transformations_unit_test.py

@@ -0,0 +1,178 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Unit tests for transformations module
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+from sigima.objects.scalar import GeometryResult, KindShape
+from sigima.objects.shape import PointCoordinates
+from sigima.proc.image.transformations import GeometryTransformer, transformer
+
+
+def test_geometry_transformer_singleton() -> None:
+    """
+    Test that GeometryTransformer follows singleton pattern.
+    """
+    t1 = GeometryTransformer()
+    t2 = GeometryTransformer()
+    assert t1 is t2
+    assert t1 is transformer
+
+
+def test_transform_geometry_result_point() -> None:
+    """
+    Test transformation of GeometryResult with POINT coordinates.
+    """
+    # Create a GeometryResult with point coordinates
+    coords = np.array([[1.0, 2.0], [3.0, 4.0]])
+    geometry = GeometryResult(
+        title="Test Points",
+        kind=KindShape.POINT,
+        coords=coords,
+        roi_indices=None,
+        attrs={},
+    )
+
+    # Test rotation
+    rotated = transformer.rotate(geometry, np.pi / 2, center=(0, 0))
+    expected_coords = np.array([[-2.0, 1.0], [-4.0, 3.0]])
+    assert np.allclose(rotated.coords, expected_coords)
+    assert rotated.title == geometry.title
+    assert rotated.kind == geometry.kind
+
+    # Test translation
+    translated = transformer.translate(geometry, 10.0, 20.0)
+    expected_coords = np.array([[11.0, 22.0], [13.0, 24.0]])
+    assert np.allclose(translated.coords, expected_coords)
+
+    # Original should be unchanged
+    assert np.allclose(geometry.coords, coords)
+
+
+def test_transform_geometry_result_rectangle() -> None:
+    """
+    Test transformation of GeometryResult with RECTANGLE coordinates.
+    """
+    # Create a GeometryResult with rectangle coordinates (x0, y0, dx, dy)
+    coords = np.array([[0.0, 0.0, 3.0, 1.0], [10.0, 10.0, 2.0, 4.0]])
+    geometry = GeometryResult(
+        title="Test Rectangles",
+        kind=KindShape.RECTANGLE,
+        coords=coords,
+        roi_indices=None,
+        attrs={},
+    )
+
+    # Test horizontal flip around x=1
+    flipped = transformer.fliph(geometry, cx=1.0)
+    expected_coords = np.array([[-1.0, 0.0, 3.0, 1.0], [-10.0, 10.0, 2.0, 4.0]])
+    assert np.allclose(flipped.coords, expected_coords)
+
+    # Test transpose
+    transposed = transformer.transpose(geometry)
+    expected_coords = np.array([[0.0, 0.0, 1.0, 3.0], [10.0, 10.0, 4.0, 2.0]])
+    assert np.allclose(transposed.coords, expected_coords)
+
+
+def test_transform_geometry_result_circle() -> None:
+    """
+    Test transformation of GeometryResult with CIRCLE coordinates.
+    """
+    # Create a GeometryResult with circle coordinates
+    coords = np.array([[1.0, 2.0, 5.0], [10.0, 20.0, 10.0]])
+    geometry = GeometryResult(
+        title="Test Circles",
+        kind=KindShape.CIRCLE,
+        coords=coords,
+        roi_indices=None,
+        attrs={},
+    )
+
+    # Test scaling (only center should be scaled, radius unchanged)
+    scaled = transformer.scale(geometry, 2.0, 3.0, center=(0, 0))
+    expected_coords = np.array([[2.0, 6.0, 5.0], [20.0, 60.0, 10.0]])
+    assert np.allclose(scaled.coords, expected_coords)
+
+
+def test_geometry_transformer_generic_methods() -> None:
+    """
+    Test generic transform_geometry method.
+    """
+    coords = np.array([[1.0, 2.0]])
+    geometry = GeometryResult(
+        title="Test Point",
+        kind=KindShape.POINT,
+        coords=coords,
+        roi_indices=None,
+        attrs={},
+    )
+
+    # Test generic method
+    rotated = transformer.transform_geometry(
+        geometry, "rotate", angle=np.pi / 2, center=(0, 0)
+    )
+    expected_coords = np.array([[-2.0, 1.0]])
+    assert np.allclose(rotated.coords, expected_coords)
+
+
+def test_unsupported_geometry_kind() -> None:
+    """
+    Test error handling for unsupported geometry kinds.
+    """
+    # Create invalid geometry kind (this would need to be added to KindShape enum)
+    try:
+        # This should raise an error if we had an unsupported kind
+        # For now, all defined kinds are supported
+        pass
+    except ValueError:
+        pass
+
+
+def test_unsupported_operation() -> None:
+    """
+    Test error handling for unsupported operations.
+    """
+    coords = np.array([[1.0, 2.0]])
+    geometry = GeometryResult(
+        title="Test Point",
+        kind=KindShape.POINT,
+        coords=coords,
+        roi_indices=None,
+        attrs={},
+    )
+
+    try:
+        transformer.transform_geometry(geometry, "invalid_operation")
+        assert False, "Should have raised ValueError"
+    except ValueError as e:
+        assert "Unknown operation" in str(e)
+
+
+def test_direct_coordinate_transformation() -> None:
+    """
+    Test that transformations use the shape coordinate system correctly.
+    """
+    # Test that our transformer produces the same results as direct shape
+    # coordinate usage
+    coords = np.array([[2.0, 3.0]])
+    geometry = GeometryResult(
+        title="Test Point",
+        kind=KindShape.POINT,
+        coords=coords,
+        roi_indices=None,
+        attrs={},
+    )
+
+    # Transform using transformer
+    rotated_geometry = transformer.rotate(geometry, np.pi / 2, center=(1, 1))
+
+    # Transform using shape coordinates directly
+    shape_coords = PointCoordinates([2.0, 3.0])
+    shape_coords.rotate(np.pi / 2, center=(1, 1))
+
+    # Results should be identical
+    assert np.allclose(rotated_geometry.coords[0], shape_coords.data)

sigima/tests/common/validation_unit_test.py

@@ -0,0 +1,205 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Testing validation test introspection and CSV generation.
+"""
+
+import os.path as osp
+
+import sigima.tests as tests_pkg
+from sigima.proc.decorator import find_computation_functions
+from sigima.proc.validation import (
+    ValidationStatistics,
+    generate_valid_test_names_for_function,
+    get_validation_tests,
+)
+from sigima.tests.helpers import WorkdirRestoringTempDir
+
+
+def __generate_all_valid_test_names() -> set[str]:
+    """Generate all valid test names for all computation functions.
+
+    Returns:
+        Set of all valid test names that could test computation functions
+    """
+    computation_functions = find_computation_functions()
+    valid_test_names = set()
+
+    for module_name, func_name, _ in computation_functions:
+        names = generate_valid_test_names_for_function(module_name, func_name)
+        valid_test_names.update(names)
+
+    return valid_test_names
+
+
+def test_validation_statistics() -> None:
+    """Test validation statistics introspection and CSV generation."""
+    stats = ValidationStatistics()
+    stats.collect_validation_status(verbose=True)
+    stats.get_validation_info()
+    with WorkdirRestoringTempDir() as tmpdir:
+        stats.generate_csv_files(tmpdir)
+        stats.generate_statistics_csv(tmpdir)
+
+
+def test_validation_missing_tests() -> None:
+    """Test that all computation functions have validation tests.
+
+    This test ensures that all computation functions (those decorated with
+    @computation_function) have corresponding validation tests
+    marked with @pytest.mark.validation.
+    """
+    # Get all functions marked with @pytest.mark.validation
+    validation_tests = get_validation_tests(tests_pkg)
+
+    # Get all computation functions that should have validation tests
+    computation_functions = find_computation_functions()
+    required_functions = [
+        (module_name, func_name) for module_name, func_name, _ in computation_functions
+    ]
+
+    # Check each required function to see if it has a corresponding validation test
+    missing_validation_tests = []
+
+    for module_name, func_name in required_functions:
+        valid_test_names = generate_valid_test_names_for_function(
+            module_name, func_name
+        )
+
+        # Check if any of the valid test names exist in validation tests
+        has_validation_test = any(
+            test_name in [vt[0] for vt in validation_tests]
+            for test_name in valid_test_names
+        )
+
+        if not has_validation_test:
+            missing_validation_tests.append(f"{module_name}.{func_name}")
+
+    # Report any missing validation tests
+    if missing_validation_tests:
+        error_messages = []
+        error_messages.append(
+            "The following computation functions are missing "
+            "validation tests marked with @pytest.mark.validation:"
+        )
+        for func_name in missing_validation_tests:
+            error_messages.append(f"  - {func_name}")
+        error_messages.append("")
+        error_messages.append(f"Found {len(missing_validation_tests)} missing cases.")
+        error_messages.append(
+            "Please add validation tests for these computation functions."
+        )
+
+        raise AssertionError("\n".join(error_messages))
+
+
+def test_validation_decorator_only_on_computation_functions() -> None:
+    """Test that @pytest.mark.validation is only used on computation function tests.
+
+    This test ensures that validation tests marked with @pytest.mark.validation
+    are only used for testing actual computation functions (those decorated with
+    @computation_function). Test functions for non-computation functions (like
+    I/O convenience functions) should not have this decorator.
+    """
+    # Get all functions marked with @pytest.mark.validation
+    validation_tests = get_validation_tests(tests_pkg)
+
+    # Get all valid test names for computation functions
+    valid_test_names = __generate_all_valid_test_names()
+
+    # Check each validation test to see if it corresponds to a computation function
+    invalid_validation_tests = []
+
+    for test_name, test_path, line_number in validation_tests:
+        if test_name not in valid_test_names:
+            # This validation test doesn't correspond to any computation function
+            rel_path = osp.relpath(test_path, start=osp.dirname(tests_pkg.__file__))
+            module_parts = rel_path.replace(osp.sep, ".").replace(".py", "")
+            module_name = f"sigima.tests.{module_parts}"
+            invalid_validation_tests.append((test_name, module_name, line_number))
+
+    # Report any invalid validation tests
+    if invalid_validation_tests:
+        error_messages = []
+        error_messages.append(
+            "Found @pytest.mark.validation decorator on tests that don't test "
+            "computation functions:"
+        )
+        for test_name, module_name, line_number in invalid_validation_tests:
+            # Convert module path back to file path for clickable links
+            file_path = (
+                module_name.replace("sigima.tests.", "").replace(".", "\\") + ".py"
+            )
+            error_messages.append(f"  - {file_path}:{line_number} ({test_name})")
+        error_messages.append("")
+        error_messages.append(f"Found {len(invalid_validation_tests)} invalid cases.")
+        error_messages.append(
+            "The @pytest.mark.validation decorator should only be used on "
+            "test functions that test computation functions (those decorated with "
+            "@computation_function). Please remove this decorator from test functions "
+            "that test non-computation functions."
+        )
+
+        raise AssertionError("\n".join(error_messages))
+
+
+def test_computation_functions_documented_in_features() -> None:
+    """Test that all computation functions are documented in doc/features.rst.
+
+    This test ensures that all computation functions (those decorated with
+    @computation_function) are documented in the features.rst file with
+    proper Sphinx :func: references using simplified paths like
+    sigima.proc.image.function_name or sigima.proc.signal.function_name.
+    """
+    # Read the features.rst file
+    doc_dir = osp.join(osp.dirname(tests_pkg.__file__), "..", "..", "doc")
+    features_rst_path = osp.join(doc_dir, "user_guide", "features.rst")
+
+    if not osp.exists(features_rst_path):
+        raise AssertionError(f"Documentation file not found: {features_rst_path}")
+
+    with open(features_rst_path, encoding="utf-8") as f:
+        features_content = f.read()
+
+    # Get all computation functions
+    computation_functions = find_computation_functions()
+
+    # Check each computation function to see if it's documented
+    missing_documentation = []
+
+    for module_name, func_name, _ in computation_functions:
+        # Build the expected documentation reference using simplified path
+        # The module_name is like "sigima.proc.image" or "sigima.proc.signal"
+        module_path = module_name.split("sigima.proc.")[-1]
+        expected_ref = f"sigima.proc.{module_path}.{func_name}"
+
+        # Check if this reference exists in the documentation
+        if expected_ref not in features_content:
+            missing_documentation.append((module_name, func_name, expected_ref))
+
+    # Report any missing documentation
+    if missing_documentation:
+        error_messages = []
+        error_messages.append(
+            "The following computation functions are missing from doc/features.rst:"
+        )
+        for module_name, func_name, expected_ref in missing_documentation:
+            error_messages.append(f"  - {func_name} ({expected_ref})")
+        error_messages.append("")
+        error_messages.append(f"Found {len(missing_documentation)} missing cases.")
+        error_messages.append(
+            "Please add documentation references for these computation functions "
+            "in doc/features.rst using the format:"
+        )
+        error_messages.append(
+            "   :func:`function_name <sigima.proc.module.function_name>`"
+        )
+
+        raise AssertionError("\n".join(error_messages))
+
+
+if __name__ == "__main__":
+    test_validation_statistics()
+    test_validation_missing_tests()
+    test_validation_decorator_only_on_computation_functions()
+    test_computation_functions_documented_in_features()

sigima/tests/conftest.py

@@ -0,0 +1,129 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+`sigima` pytest configuration
+-----------------------------
+
+This file contains the configuration for running pytest in `sigima`. It is
+executed before running any tests.
+"""
+
+import os
+import os.path as osp
+
+import guidata
+import h5py
+import numpy
+import pytest
+import scipy
+import skimage
+from guidata.config import ValidationMode, set_validation_mode
+from guidata.utils.gitreport import format_git_info_for_pytest, get_git_info_for_modules
+
+import sigima
+from sigima.proc.validation import ValidationStatistics
+from sigima.tests import SIGIMA_TESTS_GUI_ENV, env, helpers
+
+# Set validation mode to STRICT for all tests
+set_validation_mode(ValidationMode.STRICT)
+
+# Turn on unattended mode for executing tests without user interaction
+env.execenv.unattended = True
+env.execenv.verbose = "quiet"
+
+INITIAL_CWD = os.getcwd()
+
+
+def pytest_addoption(parser):
+    """Add custom command line options to pytest."""
+    parser.addoption(
+        "--show-windows",
+        action="store_true",
+        default=False,
+        help="Display Qt windows during tests (disables QT_QPA_PLATFORM=offscreen)",
+    )
+    parser.addoption(
+        "--gui", action="store_true", default=False, help="Run tests that require a GUI"
+    )
+
+
+def pytest_report_header(config):  # pylint: disable=unused-argument
+    """Add additional information to the pytest report header."""
+    infolist = [
+        f"sigima {sigima.__version__}",
+        f"  guidata {guidata.__version__},",
+        f"  NumPy {numpy.__version__}, SciPy {scipy.__version__}, "
+        f"h5py {h5py.__version__}, scikit-image {skimage.__version__}",
+    ]
+    try:
+        import cv2  # pylint: disable=import-outside-toplevel
+
+        infolist[-1] += f", OpenCV {cv2.__version__}"
+    except ImportError:
+        pass
+    envlist = []
+    for vname in ("SIGIMA_DATA", "PYTHONPATH", "DEBUG", "QT_API", "QT_QPA_PLATFORM"):
+        value = os.environ.get(vname, "")
+        if value:
+            if vname == "PYTHONPATH":
+                pathlist = value.split(os.pathsep)
+                envlist.append(f"  {vname}:")
+                envlist.extend(f"    {p}" for p in pathlist if p)
+            else:
+                envlist.append(f"  {vname}: {value}")
+    if envlist:
+        infolist.append("Environment variables:")
+        infolist.extend(envlist)
+    infolist.append("Test paths:")
+    for test_path in helpers.get_test_paths():
+        test_path = osp.abspath(test_path)
+        infolist.append(f"  {test_path}")
+
+    # Git information for all modules using the new gitreport module
+    modules_config = [
+        ("Sigima", sigima, "."),  # Sigima uses current directory
+        ("guidata", guidata, None),
+    ]
+    git_repos = get_git_info_for_modules(modules_config)
+    git_info_lines = format_git_info_for_pytest(git_repos, "Sigima")
+    if git_info_lines:
+        infolist.extend(git_info_lines)
+
+    infolist.extend(ValidationStatistics().get_validation_info())
+    return infolist
+
+
+def pytest_configure(config):
+    """Add custom markers to pytest."""
+    if config.option.durations is None:
+        config.option.durations = 10  # Default to showing 10 slowest tests
+    config.addinivalue_line(
+        "markers",
+        "validation: mark a test as a validation test (ground truth or analytical)",
+    )
+    if not config.getoption("--show-windows"):
+        os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
+    config.addinivalue_line("markers", "gui: mark test as requiring GUI")
+    if config.getoption("--gui"):
+        os.environ[SIGIMA_TESTS_GUI_ENV] = "1"
+    else:
+        os.environ.pop(SIGIMA_TESTS_GUI_ENV, None)
+
+
+def pytest_collection_modifyitems(config, items):
+    """Modify collected test items based on command line options."""
+    if config.getoption("--gui"):
+        return  # User requested GUI tests
+
+    skip_gui = pytest.mark.skip(reason="GUI test: run with --gui")
+
+    for item in items:
+        if "gui" in item.keywords:
+            item.add_marker(skip_gui)
+
+
+@pytest.fixture(autouse=True)
+def reset_cwd(request):  # pylint: disable=unused-argument
+    """Reset the current working directory to the initial one after each test."""
+    yield
+    os.chdir(INITIAL_CWD)