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

sigima/tests/image/blob_detection_unit_test.py

@@ -0,0 +1,312 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Blob detection tests
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# pylint: disable=duplicate-code
+
+from __future__ import annotations
+
+import importlib.util
+
+import numpy as np
+import pytest
+
+import sigima.objects
+import sigima.params
+import sigima.proc.image
+from sigima.tests import guiutils
+from sigima.tests.env import execenv
+
+CV2_AVAILABLE = importlib.util.find_spec("cv2") is not None
+
+
+def create_simple_blob_test_image() -> np.ndarray:
+    """Create a simple test image with one obvious blob for debugging.
+
+    Returns:
+        Simple test image with a clear blob
+    """
+    # Create a simple 100x100 image with a clear circular blob
+    size = 100
+    data = np.zeros((size, size), dtype=np.float64)
+
+    # Add a clear circular blob in the center
+    y, x = np.ogrid[:size, :size]
+    center_x, center_y = size // 2, size // 2
+    radius = 10
+
+    # Create a circular blob (step function, not Gaussian)
+    mask = (x - center_x) ** 2 + (y - center_y) ** 2 < radius**2
+    data[mask] = 1.0
+
+    # Keep as float64 for blob detection
+    return data
+
+
+def create_blob_test_image(
+    size: int = 200,
+    n_blobs: int = 5,
+    blob_radius: float = 10.0,
+    blob_intensity: float = 1000.0,
+    noise_level: float = 50.0,
+    seed: int | None = None,
+) -> tuple[np.ndarray, np.ndarray]:
+    """Create a test image with synthetic blobs for blob detection testing.
+
+    Args:
+        size: Image size (square image)
+        n_blobs: Number of blobs to create
+        blob_radius: Radius of the blobs in pixels
+        blob_intensity: Intensity of the blobs
+        noise_level: Standard deviation of Gaussian noise
+        seed: Random seed for reproducible results
+
+    Returns:
+        Tuple of (image_data, expected_coords) where expected_coords is an array
+        of shape (n_blobs, 3) with columns [x, y, radius]
+    """
+    rng = np.random.default_rng(seed)
+
+    # Create base image with noise
+    data = rng.normal(0, noise_level, size=(size, size)).astype(np.float64)
+
+    # Generate blob centers avoiding edges
+    margin = int(blob_radius * 2)
+    valid_range = size - 2 * margin
+
+    blob_centers = []
+    for _ in range(n_blobs):
+        x = margin + rng.random() * valid_range
+        y = margin + rng.random() * valid_range
+        blob_centers.append((x, y))
+
+    # Add circular blobs to the image
+    expected_coords = []
+    y_grid, x_grid = np.ogrid[:size, :size]
+
+    for x_center, y_center in blob_centers:
+        # Create a circular blob using step function
+        mask = (x_grid - x_center) ** 2 + (y_grid - y_center) ** 2 < blob_radius**2
+        data[mask] += blob_intensity
+
+        # Store expected coordinates with radius
+        expected_coords.append([x_center, y_center, blob_radius])
+
+    # Ensure positive values and convert to float64 for blob detection
+    data = np.maximum(data, 0)
+    data = data.astype(np.float64)
+    # Normalize to [0, 1] range for blob detection algorithms
+    if data.max() > 0:
+        data = data / data.max()
+
+    return data, np.array(expected_coords)
+
+
+@pytest.mark.validation
+def test_image_blob_dog():
+    """Blob detection using Difference of Gaussian (DoG) method validation test"""
+    execenv.print("Testing blob_dog detection...")
+
+    # Test 1: Simple single blob
+    data = create_simple_blob_test_image()
+    obj = sigima.objects.create_image("blob_dog_simple", data=data)
+    param = sigima.params.BlobDOGParam.create(
+        min_sigma=1.0,
+        max_sigma=20.0,
+        threshold_rel=0.01,
+        overlap=0.5,
+        exclude_border=False,
+    )
+    result = sigima.proc.image.blob_dog(obj, param)
+    assert result is not None, "Simple blob detection should return results"
+    assert len(result.coords) > 0, "Should detect at least one blob in simple case"
+    execenv.print(f"✓ DoG simple: detected {len(result.coords)} blobs")
+
+    # Test 2: Multiple blobs (simplified)
+    data, expected_coords = create_blob_test_image(
+        size=150, n_blobs=2, blob_radius=12.0, noise_level=0.1, seed=42
+    )
+    obj = sigima.objects.create_image("blob_dog_multi", data=data)
+    param = sigima.params.BlobDOGParam.create(
+        min_sigma=5.0,
+        max_sigma=20.0,
+        threshold_rel=0.05,
+        overlap=0.3,
+        exclude_border=True,
+    )
+    result = sigima.proc.image.blob_dog(obj, param)
+    guiutils.view_images_if_gui(
+        obj,
+        title="DoG multi blob detection test image",
+        results=[result],
+        colormap="gray",
+    )
+    if result is not None and len(result.coords) > 0:
+        detected_count = len(result.coords)
+        expected_count = len(expected_coords)
+        execenv.print(
+            f"✓ DoG multi: detected {detected_count} blobs (expected ~{expected_count})"
+        )
+        # Validate coordinate format: should be [x, y, radius]
+        assert result.coords.shape[1] == 3, (
+            "Coordinates should have 3 columns [x, y, radius]"
+        )
+        # Check that all radii are positive
+        assert np.all(result.coords[:, 2] > 0), (
+            "All detected blob radii should be positive"
+        )
+    else:
+        execenv.print("✓ DoG multi: no blobs detected (acceptable for noisy case)")
+
+
+@pytest.mark.validation
+def test_image_blob_doh():
+    """Blob detection using Determinant of Hessian (DoH) method validation test"""
+    execenv.print("Testing blob_doh detection...")
+
+    # Start with a simple test case
+    data = create_simple_blob_test_image()
+    obj = sigima.objects.create_image("blob_doh_test", data=data)
+    param = sigima.params.BlobDOHParam.create(
+        min_sigma=1.0,
+        max_sigma=20.0,
+        threshold_rel=0.01,
+        overlap=0.5,
+        log_scale=False,
+    )
+    result = sigima.proc.image.blob_doh(obj, param)
+    assert result is not None, "Blob detection should return results"
+    assert len(result.coords) > 0, "Should detect at least one blob"
+    execenv.print(f"✓ DoH: detected {len(result.coords)} blobs")
+
+
+@pytest.mark.validation
+def test_image_blob_log():
+    """Blob detection using Laplacian of Gaussian (LoG) method validation test"""
+    execenv.print("Testing blob_log detection...")
+
+    # Start with a simple test case
+    data = create_simple_blob_test_image()
+    obj = sigima.objects.create_image("blob_log_test", data=data)
+    param = sigima.params.BlobLOGParam.create(
+        min_sigma=1.0,
+        max_sigma=20.0,
+        threshold_rel=0.01,
+        overlap=0.5,
+        log_scale=False,
+        exclude_border=False,
+    )
+    result = sigima.proc.image.blob_log(obj, param)
+    assert result is not None, "Blob detection should return results"
+    assert len(result.coords) > 0, "Should detect at least one blob"
+    execenv.print(f"✓ LoG: detected {len(result.coords)} blobs")
+
+
+@pytest.mark.validation
+@pytest.mark.skipif(not CV2_AVAILABLE, reason="OpenCV (cv2) is not available")
+def test_image_blob_opencv():
+    """Blob detection using OpenCV method validation test"""
+    execenv.print("Testing blob_opencv detection...")
+
+    # Start with a simple test case
+    data = create_simple_blob_test_image()
+    obj = sigima.objects.create_image("blob_opencv_test", data=data)
+    param = sigima.params.BlobOpenCVParam.create(
+        min_threshold=10.0,
+        max_threshold=200.0,
+        min_repeatability=2,
+        min_dist_between_blobs=10.0,
+        filter_by_color=False,
+        blob_color=0,
+        filter_by_area=True,
+        min_area=10.0,
+        max_area=1000.0,
+        filter_by_circularity=False,
+        min_circularity=0.1,
+        max_circularity=1.0,
+        filter_by_inertia=False,
+        min_inertia_ratio=0.1,
+        max_inertia_ratio=1.0,
+        filter_by_convexity=False,
+        min_convexity=0.1,
+        max_convexity=1.0,
+    )
+    result = sigima.proc.image.blob_opencv(obj, param)
+    assert result is not None, "Blob detection should return results"
+    assert len(result.coords) > 0, "Should detect at least one blob"
+    execenv.print(f"✓ OpenCV: detected {len(result.coords)} blobs")
+
+
+def test_blob_detection_consistency():
+    """Test that different blob detection methods produce consistent results"""
+    execenv.print("Testing blob detection consistency across methods...")
+
+    # Create a simple test image with well-separated blobs
+    data = create_simple_blob_test_image()
+
+    # Test parameters for each method
+    methods_and_params = [
+        (
+            "dog",
+            sigima.params.BlobDOGParam.create(
+                min_sigma=1.0, max_sigma=20.0, threshold_rel=0.01, overlap=0.3
+            ),
+        ),
+        (
+            "log",
+            sigima.params.BlobLOGParam.create(
+                min_sigma=1.0, max_sigma=20.0, threshold_rel=0.01, overlap=0.3
+            ),
+        ),
+        (
+            "doh",
+            sigima.params.BlobDOHParam.create(
+                min_sigma=1.0, max_sigma=20.0, threshold_rel=0.01, overlap=0.3
+            ),
+        ),
+    ]
+
+    results = {}
+    for method_name, param in methods_and_params:
+        obj = sigima.objects.create_image(f"blob_{method_name}_consistency", data=data)
+
+        if method_name == "dog":
+            result = sigima.proc.image.blob_dog(obj, param)
+        elif method_name == "log":
+            result = sigima.proc.image.blob_log(obj, param)
+        elif method_name == "doh":
+            result = sigima.proc.image.blob_doh(obj, param)
+
+        results[method_name] = result
+        if result is not None:
+            execenv.print(f"{method_name.upper()}: detected {len(result.coords)} blobs")
+        else:
+            execenv.print(f"{method_name.upper()}: no blobs detected")
+
+    # All methods should detect at least one blob (or we skip if none work)
+    working_methods = [
+        name
+        for name, result in results.items()
+        if result is not None and len(result.coords) > 0
+    ]
+
+    if len(working_methods) == 0:
+        pytest.skip("No blob detection methods returned results")
+
+    for method_name, result in results.items():
+        if result is not None:
+            assert len(result.coords) > 0, (
+                f"{method_name} should detect at least one blob"
+            )
+
+
+if __name__ == "__main__":
+    guiutils.enable_gui()
+    test_image_blob_dog()
+    test_image_blob_doh()
+    test_image_blob_log()
+    test_image_blob_opencv()
+    test_blob_detection_consistency()

sigima/tests/image/centroid_unit_test.py

@@ -0,0 +1,170 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Image centroid computation test
+
+Comparing different algorithms for centroid calculation:
+
+- SciPy (measurements.center_of_mass)
+- OpenCV (moments)
+- Method based on moments
+- Method based on Fourier (Sigima's algorithm)
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+# pylint: disable=duplicate-code
+
+from __future__ import annotations
+
+import time
+
+import numpy as np
+import pytest
+from numpy import ma
+from skimage import measure
+
+import sigima.objects
+import sigima.proc.image
+import sigima.tools.image
+from sigima.config import _
+from sigima.tests import guiutils
+from sigima.tests.data import (
+    create_noisy_gaussian_image,
+    get_laser_spot_data,
+    get_test_image,
+)
+from sigima.tests.env import execenv
+from sigima.tests.helpers import check_scalar_result
+
+
+def get_centroid_from_moments(data: np.ndarray) -> tuple[int, int]:
+    """Computing centroid from image moments
+
+    Args:
+        data: 2D array of image data
+
+    Returns:
+        Tuple with centroid coordinates (y, x)
+    """
+    y, x = np.ogrid[: data.shape[0], : data.shape[1]]
+    imx, imy = data.sum(axis=0)[None, :], data.sum(axis=1)[:, None]
+    m00 = np.array(data, dtype=float).sum() or 1.0
+    m10 = (np.array(imx, dtype=float) * x).sum() / m00
+    m01 = (np.array(imy, dtype=float) * y).sum() / m00
+    return int(m01), int(m10)
+
+
+def get_centroid_with_cv2(data: np.ndarray) -> tuple[int, int]:
+    """Compute centroid from moments with OpenCV
+
+    Args:
+        data: 2D array of image data
+
+    Returns:
+        Tuple with centroid coordinates (y, x)
+    """
+    import cv2  # pylint: disable=import-outside-toplevel
+
+    m = cv2.moments(data)
+    col = int(m["m10"] / m["m00"])
+    row = int(m["m01"] / m["m00"])
+    return row, col
+
+
+def __compare_centroid_funcs(data: np.ndarray) -> None:
+    """Compare different centroid computation methods
+
+    Args:
+        data: 2D array of image data
+    """
+    # pylint: disable=import-outside-toplevel
+    from plotpy.builder import make
+
+    from sigima.tests import vistools
+
+    items = []
+    items += [make.image(data, interpolation="nearest", eliminate_outliers=2.0)]
+    # Computing centroid coordinates
+    for name, func in (
+        # ("SciPy", spi.center_of_mass),
+        # ("OpenCV", get_centroid_with_cv2),
+        ("scikit-image", measure.centroid),
+        # ("Moments", get_centroid_from_moments),
+        ("Fourier", sigima.tools.image.get_centroid_fourier),
+        ("Auto", sigima.tools.image.get_centroid_auto),
+        ("Projected Profile Median", sigima.tools.image.get_projected_profile_centroid),
+        (
+            "Projected Profile Barycenter",
+            lambda d: sigima.tools.image.get_projected_profile_centroid(
+                d, method="barycenter"
+            ),
+        ),
+    ):
+        try:
+            t0 = time.time()
+            y, x = func(data)
+            dt = time.time() - t0
+            label = "  " + f"{_('Centroid')}[{name}] (x=%s, y=%s)"
+            execenv.print(label % (x, y))
+            cursor = make.xcursor(x, y, label=label)
+            cursor.setTitle(name)
+            items.append(cursor)
+            execenv.print(f"    Calculation time: {int(dt * 1e3):d} ms")
+        except ImportError:
+            execenv.print(f"    Unable to compute {name}: missing module")
+    vistools.view_image_items(items)
+
+
+@pytest.mark.gui
+def test_image_centroid_interactive() -> None:
+    """Interactive test for image centroid computation
+
+    This test will display the centroid of laser spot data using different methods.
+    It will also print the centroid coordinates and computation time for each method.
+    """
+    with guiutils.lazy_qt_app_context(force=True):
+        centroid_test_data = get_test_image("centroid_test.npy").data
+        for data in get_laser_spot_data() + [centroid_test_data]:
+            execenv.print(f"Data[dtype={data.dtype},shape={data.shape}]")
+            # Testing with masked arrays
+            __compare_centroid_funcs(data.view(ma.MaskedArray))
+
+
+def __check_centroid(
+    image: sigima.objects.ImageObj, expected_x: float, expected_y: float, debug_str: str
+) -> None:
+    """Check centroid computation
+
+    Args:
+        image: Image object to compute centroid from
+        expected_x: Expected x coordinate of the centroid
+        expected_y: Expected y coordinate of the centroid
+        debug_str: Debug string for logging
+    """
+    geometry = sigima.proc.image.centroid(image)
+    x, y = geometry.coords[0]
+    check_scalar_result(f"Centroid X [{debug_str}]", x, expected_x, atol=1.0)
+    check_scalar_result(f"Centroid Y [{debug_str}]", y, expected_y, atol=1.0)
+
+
+@pytest.mark.validation
+def test_image_centroid() -> None:
+    """Test centroid computation"""
+    param = sigima.objects.NewImageParam.create(height=500, width=500)
+    image = create_noisy_gaussian_image(param, center=(-2.0, 3.0), add_annotations=True)
+    circle_roi = sigima.objects.create_image_roi("circle", [200, 325, 10], indices=True)
+    for roi, x0, y0 in (
+        (None, 0.0, 0.0),
+        (None, 100.0, 100.0),
+        (circle_roi, 0.0, 0.0),
+        (circle_roi, 100.0, 100.0),  # Test for regression like #106
+    ):
+        image.roi = roi
+        image.set_uniform_coords(image.dx, image.dy, x0, y0)
+        debug_str = f"{roi}, x0: {x0}, y0: {y0}"
+        __check_centroid(image, 200.0 + x0, 325.0 + y0, debug_str)
+
+
+if __name__ == "__main__":
+    test_image_centroid_interactive()
+    test_image_centroid()

sigima/tests/image/check_2d_array_unit_test.py

@@ -0,0 +1,63 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""Unit tests for 2D-array function checks decorators."""
+
+import numpy as np
+import pytest
+
+from sigima.tools.checks import check_2d_array
+
+
+@check_2d_array(dtype=np.floating)
+def identity(data: np.ndarray) -> np.ndarray:
+    """Dummy image function returning input."""
+    return data
+
+
+def test_valid_2d_float_input() -> None:
+    """Test with valid 2D float array."""
+    data = np.array([[1.0, 2.0], [3.0, 4.0]], dtype=np.float64)
+    result = identity(data)
+    np.testing.assert_array_equal(result, data)
+
+
+def test_wrong_ndim() -> None:
+    """Test with non-2D input."""
+    data = np.array([1.0, 2.0, 3.0], dtype=float)  # 1D
+    with pytest.raises(ValueError, match="Input array must be 2D"):
+        identity(data)
+
+
+def test_wrong_dtype() -> None:
+    """Test with wrong dtype."""
+    data = np.array([[1, 2], [3, 4]], dtype=int)
+    with pytest.raises(
+        TypeError, match="Input array must be of type <class 'numpy.floating'>"
+    ):
+        identity(data)
+
+
+@check_2d_array(non_constant=True)
+def normalize(data: np.ndarray) -> np.ndarray:
+    """Normalize 2D array to range [0, 1]."""
+    return data / np.nanmax(data)
+
+
+def test_non_constant_error() -> None:
+    """Test with non-constant input."""
+    data = np.full((3, 3), 5.0)
+    with pytest.raises(ValueError, match="Input array has no dynamic range."):
+        normalize(data)
+
+
+@check_2d_array(finite_only=True)
+def sum_image(data: np.ndarray) -> float:
+    """Sum all finite values in a 2D array."""
+    return np.sum(data)
+
+
+def test_non_finite_values() -> None:
+    """Test with non-finite values."""
+    data = np.array([[1.0, np.inf], [3.0, np.nan]])
+    with pytest.raises(ValueError, match="Input array contains non-finite values."):
+        sum_image(data)