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

sigima/tests/common/decorator_unit_test.py

@@ -0,0 +1,176 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Testing the decorator for computation functions.
+
+This test checks:
+  - The decorator can be applied to a function
+  - The function can be called with and without DataSet parameters
+  - The metadata is correctly set and can be introspected
+"""
+
+from __future__ import annotations
+
+import guidata.dataset as gds
+import numpy as np
+
+from sigima.objects import ImageObj, SignalObj, create_image, create_signal
+from sigima.proc.base import dst_1_to_1
+from sigima.proc.decorator import (
+    computation_function,
+    get_computation_metadata,
+    is_computation_function,
+)
+from sigima.tests.helpers import check_array_result
+
+
+class DummySignalParam(gds.DataSet):
+    """Dummy DataSet for testing purposes"""
+
+    a = gds.FloatItem("X value", default=1.0)
+    b = gds.FloatItem("Y value", default=5.0)
+    methods = (("linear", "Linear"), ("quadratic", "Quadratic"))
+    method = gds.ChoiceItem("Method", choices=methods, default="linear")
+
+
+SCF_NAME = "dummy_signal_func"
+SCF_DESCRIPTION = "A dummy signal function"
+
+
+@computation_function(name=SCF_NAME, description=SCF_DESCRIPTION)
+def dummy_signal_func(src: SignalObj, p: DummySignalParam) -> SignalObj:
+    """A dummy function that adds two parameters from a DataSet.
+
+    Args:
+        src: The source SignalObj.
+        param: The parameters from the DummySignalParam DataSet.
+
+    Returns:
+        The signal with the operation applied.
+    """
+    dst = dst_1_to_1(src, SCF_NAME, f"x={p.a:.3f}, y={p.b:.3f}")
+    if p.method == "linear":
+        dst.y = src.y + src.x * p.a + p.b
+    else:  # Quadratic method
+        dst.y = src.y + src.x**2 * p.a + p.b
+    return dst
+
+
+class DummyImageParam(gds.DataSet):
+    """Dummy DataSet for testing purposes"""
+
+    alpha = gds.FloatItem("Alpha value", default=0.5)
+
+
+ICF_NAME = "dummy_image_func"
+ICF_DESCRIPTION = "A dummy image function"
+
+
+@computation_function(name=ICF_NAME, description=ICF_DESCRIPTION)
+def dummy_image_func(src: ImageObj, param: DummyImageParam) -> ImageObj:
+    """A dummy function that applies a simple operation based on a DataSet parameter.
+
+    Args:
+        src: The source ImageObj.
+        param: The parameters from the DummyImageParam DataSet.
+
+    Returns:
+        The image with the operation applied.
+    """
+    dst = dst_1_to_1(src, ICF_NAME, f"sigma={param.alpha:.3f}")
+    dst.data = src.data * param.alpha  # Simplified operation for testing
+    return dst
+
+
+def test_signal_decorator_marker() -> None:
+    """Test the computation function decorator marker for signals"""
+    # Check if the function is marked as a computation function
+    assert is_computation_function(dummy_signal_func)
+
+
+def test_signal_decorator_metadata() -> None:
+    """Test the computation function decorator metadata for signals"""
+    # Check if the metadata is correctly set
+    metadata = get_computation_metadata(dummy_signal_func)
+    assert metadata.name == SCF_NAME
+    assert metadata.description == SCF_DESCRIPTION
+
+
+def test_signal_decorator_signature() -> None:
+    """Test the computation function decorator signature for signals"""
+    x = np.linspace(0, 10, 100)
+    orig = create_signal("test_signal", x=x, y=x)
+
+    # Call the function with a DataSet parameter
+    p = DummySignalParam.create(a=3.0, b=4.0, method="quadratic")
+    res_ds = dummy_signal_func(orig, p)
+    name = "Signal[DataSet parameter]"
+    check_array_result(f"{name} x", res_ds.x, orig.x)
+    check_array_result(f"{name} y", res_ds.y, orig.y + orig.x**2 * 3.0 + 4.0)
+
+    # Call the function with keyword arguments
+    # pylint: disable=no-value-for-parameter
+    res_kw = dummy_signal_func(orig, a=3.0, b=4.0)
+    name = "Signal[keyword arguments]"
+    check_array_result(f"{name} x", res_kw.x, orig.x)
+    check_array_result(f"{name} y", res_kw.y, orig.y + orig.x * 3.0 + 4.0)
+
+    # Call the function with both DataSet and keyword arguments
+    # The DataSet should take precedence, kwargs for DataSet items are ignored
+    res_both = dummy_signal_func(orig, p, a=100.0, b=200.0, method="linear")
+    # The result should match the DataSet values, not the conflicting kwargs
+    check_array_result(
+        "Signal[DataSet param + kwargs: DataSet wins] x", res_both.x, orig.x
+    )
+    check_array_result(
+        "Signal[DataSet param + kwargs: DataSet wins] y",
+        res_both.y,
+        orig.y + orig.x**2 * 3.0 + 4.0,
+    )
+
+
+def test_image_decorator_marker() -> None:
+    """Test the computation function decorator marker for images"""
+    # Check if the function is marked as a computation function
+    assert is_computation_function(dummy_image_func)
+
+
+def test_image_decorator_metadata() -> None:
+    """Test the computation function decorator metadata for images"""
+    # Check if the metadata is correctly set
+    metadata = get_computation_metadata(dummy_image_func)
+    assert metadata.name == ICF_NAME
+    assert metadata.description == ICF_DESCRIPTION
+
+
+def test_image_decorator_signature() -> None:
+    """Test the computation function decorator signature for images"""
+    orig = create_image("test_image", data=np.random.rand(64, 64))
+
+    # Call the function with an ImageObj and DummyImageParam
+    p = DummyImageParam.create(alpha=0.8)
+    res_ds = dummy_image_func(orig, p)
+    check_array_result("Image data", res_ds.data, orig.data * p.alpha)
+
+    # Call the function with keyword arguments
+    # pylint: disable=no-value-for-parameter
+    res_kw = dummy_image_func(orig, alpha=0.8)
+    check_array_result("Image data", res_kw.data, orig.data * 0.8)
+
+    # Call the function with both DataSet and keyword arguments
+    # The DataSet should take precedence, kwargs for DataSet items are ignored
+    res_both = dummy_image_func(orig, p, alpha=0.4)
+    check_array_result(
+        "Image data [DataSet param + kwargs: DataSet wins]",
+        res_both.data,
+        orig.data * p.alpha,
+    )
+
+
+if __name__ == "__main__":
+    test_signal_decorator_marker()
+    test_signal_decorator_metadata()
+    test_signal_decorator_signature()
+    test_image_decorator_marker()
+    test_image_decorator_metadata()
+    test_image_decorator_signature()

sigima/tests/common/examples_unit_test.py

@@ -0,0 +1,104 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Test for documentation examples
+
+This module automatically discovers and executes all Python files in the
+doc/examples directory to ensure they run without errors.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import sys
+from pathlib import Path
+
+import pytest
+
+import sigima
+from sigima.client.stub import patch_simpleremoteproxy_for_stub
+
+# Check if plotpy is available
+try:
+    import plotpy  # pylint: disable=unused-import  # noqa: F401
+
+    PLOTPY_AVAILABLE = True
+except ImportError:
+    PLOTPY_AVAILABLE = False
+
+
+def get_example_dir() -> Path:
+    """Get the path to the examples directory."""
+    return Path(sigima.__file__).parent.parent / "doc" / "examples"
+
+
+def get_example_files() -> list[Path]:
+    """Get all Python files in doc/examples directory."""
+    examples_dir = get_example_dir()
+    if not examples_dir.exists():
+        return []
+
+    return [
+        f
+        for f in examples_dir.glob("*.py")
+        if not f.name.startswith("_") and f.name != "__init__.py"
+    ]
+
+
+def test_examples_directory_exists() -> None:
+    """Test that the examples directory exists and contains Python files."""
+    examples_dir = get_example_dir()
+    assert examples_dir.exists(), "doc/examples directory should exist"
+
+    python_files = list(examples_dir.rglob("*.py"))
+    assert len(python_files) > 0, "doc/examples should contain at least one Python file"
+
+
+@pytest.mark.skipif(not PLOTPY_AVAILABLE, reason="PlotPy not installed")
+@pytest.mark.parametrize("example_file", get_example_files())
+def test_example_execution(example_file: Path) -> None:
+    """Test that each example file can be executed without errors."""
+    # Special handling for datalab_client.py - needs a stub server
+    if example_file.name == "datalab_client.py":
+        # Use the utility to patch SimpleRemoteProxy for stub server
+        stub_server = patch_simpleremoteproxy_for_stub()
+        try:
+            # Load and execute the module
+            _execute_example_module(example_file)
+        finally:
+            # Clean up the stub server
+            stub_server.stop()
+    else:
+        # Normal execution for other examples
+        _execute_example_module(example_file)
+
+
+def _execute_example_module(example_file: Path) -> None:
+    """Execute an example module file.
+
+    Args:
+        example_file: Path to the example Python file to execute
+    """
+    # Load the module
+    spec = importlib.util.spec_from_file_location(
+        f"example_{example_file.stem}", str(example_file)
+    )
+    module = importlib.util.module_from_spec(spec)
+
+    # Add the example directory to sys.path temporarily
+    examples_dir = str(example_file.parent)
+    if examples_dir not in sys.path:
+        sys.path.insert(0, examples_dir)
+
+    try:
+        # Execute the module
+        spec.loader.exec_module(module)
+    finally:
+        # Clean up sys.path
+        if examples_dir in sys.path:
+            sys.path.remove(examples_dir)
+
+
+if __name__ == "__main__":
+    # Run the tests when executed directly
+    pytest.main([__file__, "-v"])

sigima/tests/common/kernel_normalization_unit_test.py

@@ -0,0 +1,242 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""Unit tests for kernel normalization features in convolution/deconvolution."""
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+
+from sigima.config import options as sigima_options
+from sigima.objects import create_image, create_signal
+from sigima.objects.image import ImageObj
+from sigima.objects.signal import SignalObj
+from sigima.proc.image.mathops import convolution as image_convolution
+from sigima.proc.image.mathops import deconvolution as image_deconvolution
+from sigima.proc.signal import convolution as signal_convolution
+from sigima.proc.signal import deconvolution as signal_deconvolution
+
+
+def _generate_test_signal(size: int = 100) -> SignalObj:
+    """Generate a simple test signal.
+
+    Args:
+        size: The size of the signal to generate.
+
+    Returns:
+        A signal object.
+    """
+    x = np.linspace(0, 10, size)
+    y = np.sin(x) + 0.5 * np.sin(3 * x)
+    return create_signal("Test Signal", x, y)
+
+
+def _generate_unnormalized_signal_kernel(size: int = 100) -> SignalObj:
+    """Generate an unnormalized Gaussian-like kernel for signal processing.
+
+    Args:
+        size: The size of the kernel.
+
+    Returns:
+        A signal object representing an unnormalized kernel.
+
+    Notes:
+        The kernel uses the same x-axis range and size as _generate_test_signal
+        to ensure compatible sample rates for convolution and deconvolution.
+    """
+    x = np.linspace(0, 10, size)
+    y = np.exp(-((x - 5) ** 2) / 2)  # Centered Gaussian
+    y *= 2.0  # Make it unnormalized (sum != 1.0)
+    return create_signal("Unnormalized Kernel", x, y)
+
+
+def _generate_test_image(size: int = 64) -> ImageObj:
+    """Generate a simple test image.
+
+    Args:
+        size: The dimension of the square image to generate.
+
+    Returns:
+        An image object.
+    """
+    data = np.random.rand(size, size)
+    return create_image("Test Image", data)
+
+
+def _generate_unnormalized_image_kernel(size: int = 5) -> ImageObj:
+    """Generate an unnormalized Gaussian-like kernel for image processing.
+
+    Args:
+        size: The dimension of the square kernel to generate.
+
+    Returns:
+        An image object representing an unnormalized kernel.
+    """
+    kernel = np.outer(
+        np.exp(-(np.linspace(-2, 2, size) ** 2)),
+        np.exp(-(np.linspace(-2, 2, size) ** 2)),
+    )
+    kernel *= 2.0  # Make it unnormalized (sum != 1.0)
+    return create_image("Unnormalized Kernel", kernel)
+
+
+class TestKernelNormalizationSignal:
+    """Test suite for signal kernel normalization in convolution."""
+
+    @pytest.fixture(autouse=True)
+    def setup_and_teardown(self):
+        """Store initial option values and restore them after each test."""
+        # Store initial values
+        initial_auto_normalize = sigima_options.auto_normalize_kernel.get()
+
+        yield
+
+        # Restore initial values
+        sigima_options.auto_normalize_kernel.set(initial_auto_normalize)
+
+    def test_signal_convolution_auto_normalization_enabled(self):
+        """Test that auto-normalization works correctly for convolution."""
+        # Setup: auto-normalization enabled
+        sigima_options.auto_normalize_kernel.set(True)
+
+        signal = _generate_test_signal()
+        kernel = _generate_unnormalized_signal_kernel()
+
+        # Execute with auto-normalization
+        result = signal_convolution(signal, kernel)
+
+        # Verify result exists and has same shape as input
+        assert result is not None
+        assert result.data is not None
+        assert result.data.shape == signal.data.shape
+
+    def test_signal_convolution_auto_normalization_disabled(self):
+        """Test convolution with auto-normalization disabled."""
+        # Setup: auto-normalization disabled
+        sigima_options.auto_normalize_kernel.set(False)
+
+        signal = _generate_test_signal()
+        kernel = _generate_unnormalized_signal_kernel()
+
+        # Execute without auto-normalization
+        result = signal_convolution(signal, kernel)
+
+        # Verify result exists and has same shape as input
+        assert result is not None
+        assert result.data is not None
+        assert result.data.shape == signal.data.shape
+
+    def test_signal_deconvolution_auto_normalization_enabled(self):
+        """Test that auto-normalization works correctly for deconvolution."""
+        # Setup: auto-normalization enabled
+        sigima_options.auto_normalize_kernel.set(True)
+
+        signal = _generate_test_signal()
+        kernel = _generate_unnormalized_signal_kernel()
+
+        # Execute with auto-normalization
+        result = signal_deconvolution(signal, kernel)
+
+        # Verify result exists and has same shape as input
+        assert result is not None
+        assert result.data is not None
+        assert result.data.shape == signal.data.shape
+
+    def test_signal_deconvolution_auto_normalization_disabled(self):
+        """Test deconvolution with auto-normalization disabled."""
+        # Setup: auto-normalization disabled
+        sigima_options.auto_normalize_kernel.set(False)
+
+        signal = _generate_test_signal()
+        kernel = _generate_unnormalized_signal_kernel()
+
+        # Execute without auto-normalization
+        result = signal_deconvolution(signal, kernel)
+
+        # Verify result exists and has same shape as input
+        assert result is not None
+        assert result.data is not None
+        assert result.data.shape == signal.data.shape
+
+
+class TestKernelNormalizationImage:
+    """Test suite for image kernel normalization in convolution and deconvolution."""
+
+    @pytest.fixture(autouse=True)
+    def setup_and_teardown(self):
+        """Store initial option values and restore them after each test."""
+        # Store initial values
+        initial_auto_normalize = sigima_options.auto_normalize_kernel.get()
+
+        yield
+
+        # Restore initial values
+        sigima_options.auto_normalize_kernel.set(initial_auto_normalize)
+
+    def test_image_convolution_auto_normalization_enabled(self):
+        """Test that auto-normalization works correctly for convolution."""
+        # Setup: auto-normalization enabled
+        sigima_options.auto_normalize_kernel.set(True)
+
+        image = _generate_test_image()
+        kernel = _generate_unnormalized_image_kernel()
+
+        # Execute with auto-normalization
+        result = image_convolution(image, kernel)
+
+        # Verify result exists and has same shape as input
+        assert result is not None
+        assert result.data is not None
+        assert result.data.shape == image.data.shape
+
+    def test_image_convolution_auto_normalization_disabled(self):
+        """Test convolution with auto-normalization disabled."""
+        # Setup: auto-normalization disabled
+        sigima_options.auto_normalize_kernel.set(False)
+
+        image = _generate_test_image()
+        kernel = _generate_unnormalized_image_kernel()
+
+        # Execute without auto-normalization
+        result = image_convolution(image, kernel)
+
+        # Verify result exists and has same shape as input
+        assert result is not None
+        assert result.data is not None
+        assert result.data.shape == image.data.shape
+
+    def test_image_deconvolution_auto_normalization_enabled(self):
+        """Test that auto-normalization works correctly for deconvolution."""
+        # Setup: auto-normalization enabled
+        sigima_options.auto_normalize_kernel.set(True)
+
+        image = _generate_test_image()
+        kernel = _generate_unnormalized_image_kernel()
+
+        # Execute with auto-normalization
+        result = image_deconvolution(image, kernel)
+
+        # Verify result exists and has same shape as input
+        assert result is not None
+        assert result.data is not None
+        assert result.data.shape == image.data.shape
+
+    def test_image_deconvolution_auto_normalization_disabled(self):
+        """Test deconvolution with auto-normalization disabled."""
+        # Setup: auto-normalization disabled
+        sigima_options.auto_normalize_kernel.set(False)
+
+        image = _generate_test_image()
+        kernel = _generate_unnormalized_image_kernel()
+
+        # Execute without auto-normalization
+        result = image_deconvolution(image, kernel)
+
+        # Verify result exists and has same shape as input
+        assert result is not None
+        assert result.data is not None
+        assert result.data.shape == image.data.shape
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

sigima/tests/common/roi_basic_unit_test.py

@@ -0,0 +1,73 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+ROI basic unit tests
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# guitest: show
+
+from __future__ import annotations
+
+import sigima.objects
+from sigima.tests.data import (
+    create_multigaussian_image,
+    create_paracetamol_signal,
+    create_test_image_rois,
+    create_test_signal_rois,
+)
+from sigima.tests.env import execenv
+
+
+def __conversion_methods(
+    roi: sigima.objects.SignalROI | sigima.objects.ImageROI,
+    obj: sigima.objects.SignalObj | sigima.objects.ImageObj,
+) -> None:
+    """Test conversion methods for single ROI objects"""
+    execenv.print("    test `to_dict` and `from_dict` methods")
+    roi_dict = roi.to_dict()
+    roi_new = obj.get_roi_class().from_dict(roi_dict)
+    assert roi.get_single_roi(0) == roi_new.get_single_roi(0)
+
+
+def test_signal_roi_creation() -> None:
+    """Test signal ROI creation and conversion methods"""
+    obj = create_paracetamol_signal()
+    for roi in create_test_signal_rois(obj):
+        __conversion_methods(roi, obj)
+
+
+def test_image_roi_creation() -> None:
+    """Test image ROI creation and conversion methods"""
+    obj = create_multigaussian_image()
+    # Update to use new coordinate API instead of setting dx/dy directly
+    if obj.data is not None:
+        obj.set_uniform_coords(0.035, 0.035)
+    for roi in create_test_image_rois(obj):
+        __conversion_methods(roi, obj)
+
+
+def test_image_roi_modification() -> None:
+    """Test image ROI modification methods"""
+    obj = create_multigaussian_image()
+    roi = list(create_test_image_rois(obj))[0]
+
+    # Set image's ROI
+    obj.roi = roi
+    assert obj.roi == roi
+    nb_single_rois = len(roi.single_rois)
+
+    # Modify the ROI directly from the image's ROI attribute
+    # (for example, we try to remove a single ROI)
+    old_single_roi = obj.roi.single_rois.pop(0)
+    assert len(obj.roi.single_rois) == nb_single_rois - 1
+
+    # Add it back
+    obj.roi.add_roi(old_single_roi)
+    assert len(obj.roi.single_rois) == nb_single_rois
+
+
+if __name__ == "__main__":
+    test_signal_roi_creation()
+    test_image_roi_creation()
+    test_image_roi_modification()