napari-tmidas 0.2.2__py3-none-any.whl → 0.2.4__py3-none-any.whl

napari_tmidas/_tests/test_scipy_filters.py

@@ -0,0 +1,168 @@
+# src/napari_tmidas/_tests/test_scipy_filters.py
+import numpy as np
+import pytest
+
+from napari_tmidas.processing_functions import scipy_filters
+from napari_tmidas.processing_functions.scipy_filters import gaussian_blur
+
+
+class TestScipyFilters:
+    def test_resize_labels(self):
+        """Test resizing label objects while maintaining original array dimensions."""
+        from napari_tmidas.processing_functions.scipy_filters import (
+            resize_labels,
+        )
+
+        label_image = np.zeros((10, 10), dtype=np.uint8)
+        label_image[2:8, 2:8] = 3
+
+        # Test with float - dimensions should stay the same
+        scale_factor = 0.5
+        scaled = resize_labels(label_image, scale_factor=scale_factor)
+        # Function maintains original dimensions
+        assert scaled.shape == label_image.shape
+        assert set(np.unique(scaled)).issubset({0, 3})
+        # Objects should be smaller (fewer pixels with label 3)
+        assert np.sum(scaled == 3) > 0
+        assert np.sum(scaled == 3) < np.sum(label_image == 3)
+
+        # Test with string
+        scale_factor_str = "0.5"
+        scaled_str = resize_labels(label_image, scale_factor=scale_factor_str)
+        assert scaled_str.shape == label_image.shape
+        assert set(np.unique(scaled_str)).issubset({0, 3})
+        assert np.sum(scaled_str == 3) > 0
+
+    def test_gaussian_blur_basic(self):
+        """Test basic gaussian blur functionality"""
+        image = np.random.rand(100, 100)
+
+        # Test with default parameters
+        result = gaussian_blur(image)
+        assert result.shape == image.shape
+        assert result.dtype == image.dtype
+
+    def test_gaussian_blur_with_sigma(self):
+        """Test gaussian blur with custom sigma"""
+        image = np.random.rand(50, 50)
+
+        # Test with sigma parameter
+        result = gaussian_blur(image, sigma=2.0)
+        assert result.shape == image.shape
+        assert result.dtype == image.dtype
+
+    def test_gaussian_blur_3d(self):
+        """Test gaussian blur on 3D image"""
+        image = np.random.rand(20, 20, 20)
+
+        result = gaussian_blur(image, sigma=1.0)
+        assert result.shape == image.shape
+        assert result.dtype == image.dtype
+
+    @pytest.mark.skipif(
+        not scipy_filters.SCIPY_AVAILABLE, reason="SciPy is required"
+    )
+    def test_subdivide_labels_3layers_combined_output(self):
+        from napari_tmidas.processing_functions.scipy_filters import (
+            subdivide_labels_3layers,
+        )
+
+        label_image = np.zeros((9, 9), dtype=np.uint16)
+        label_image[2:7, 2:7] = 1
+
+        result = subdivide_labels_3layers(label_image)
+
+        assert result.shape == label_image.shape
+        unique_ids = set(np.unique(result))
+        assert unique_ids.issubset({0, 1, 2, 3})
+        assert {1, 2, 3}.issubset(unique_ids)
+
+    @pytest.mark.skipif(
+        not scipy_filters.SCIPY_AVAILABLE, reason="SciPy is required"
+    )
+    def test_subdivide_labels_3layers_dtype_promotion(self):
+        from napari_tmidas.processing_functions.scipy_filters import (
+            subdivide_labels_3layers,
+        )
+
+        label_image = np.zeros((9, 9), dtype=np.uint8)
+        label_image[2:7, 2:7] = 200
+
+        result = subdivide_labels_3layers(label_image)
+
+        assert result.dtype in (np.uint32, np.uint64)
+        assert result.max() == 200 + 2 * 200
+
+    @pytest.mark.skipif(
+        not scipy_filters.SCIPY_AVAILABLE, reason="SciPy is required"
+    )
+    def test_subdivide_labels_3layers_empty(self):
+        from napari_tmidas.processing_functions.scipy_filters import (
+            subdivide_labels_3layers,
+        )
+
+        label_image = np.zeros((5, 5, 5), dtype=np.uint16)
+
+        result = subdivide_labels_3layers(label_image)
+
+        np.testing.assert_array_equal(result, label_image)
+
+    @pytest.mark.skipif(
+        not scipy_filters.SCIPY_AVAILABLE, reason="SciPy is required"
+    )
+    def test_subdivide_labels_3layers_half_body(self):
+        from napari_tmidas.processing_functions.scipy_filters import (
+            subdivide_labels_3layers,
+        )
+
+        # Create a simple half-spheroid-like object
+        label_image = np.zeros((20, 20, 20), dtype=np.uint16)
+        # Fill upper half with a sphere-like object
+        for z in range(10, 20):
+            for y in range(20):
+                for x in range(20):
+                    if (z - 15) ** 2 + (y - 10) ** 2 + (x - 10) ** 2 <= 25:
+                        label_image[z, y, x] = 1
+
+        # Test with half-body mode disabled (default)
+        result_normal = subdivide_labels_3layers(
+            label_image, is_half_body=False
+        )
+        assert result_normal.shape == label_image.shape
+        unique_normal = np.unique(result_normal)
+        assert len(unique_normal) > 1  # Should have background + layers
+
+        # Test with half-body mode enabled (cut along Z-axis = 0)
+        result_half_body = subdivide_labels_3layers(
+            label_image, is_half_body=True, cut_axis=0
+        )
+        assert result_half_body.shape == label_image.shape
+        unique_half = np.unique(result_half_body)
+        assert len(unique_half) > 1  # Should have background + layers
+
+        # Both modes should produce layered results
+        # In normal mode, the cut surface (z=10 plane) may show fewer layers
+        # because it's treating it as a partial object
+        cut_surface_normal = result_normal[10, :, :]
+        cut_surface_half = result_half_body[10, :, :]
+
+        # Both should have some non-zero values at the cut surface
+        assert np.sum(cut_surface_normal > 0) > 0
+        assert np.sum(cut_surface_half > 0) > 0
+
+        # Half-body mode should ideally show more variety, but the exact
+        # behavior depends on the implementation details. Just verify both work.
+        unique_layers_normal = len(
+            np.unique(cut_surface_normal[cut_surface_normal > 0])
+        )
+        unique_layers_half = len(
+            np.unique(cut_surface_half[cut_surface_half > 0])
+        )
+        assert unique_layers_normal >= 1
+        assert unique_layers_half >= 1
+
+        # Test invalid cut_axis
+        with pytest.raises(ValueError):
+            subdivide_labels_3layers(
+                label_image, is_half_body=True, cut_axis=5
+            )

napari_tmidas/_tests/test_skimage_filters.py

@@ -0,0 +1,259 @@
+# src/napari_tmidas/_tests/test_skimage_filters.py
+import numpy as np
+
+from napari_tmidas.processing_functions.skimage_filters import (
+    adaptive_threshold_bright,
+    equalize_histogram,
+    invert_image,
+    percentile_threshold,
+    rolling_ball_background,
+    simple_thresholding,
+)
+
+
+class TestSkimageFilters:
+
+    def test_invert_image_basic(self):
+        """Test basic image inversion functionality"""
+        image = np.random.rand(100, 100)
+
+        # Test with default parameters
+        result = invert_image(image)
+        assert result.shape == image.shape
+        assert result.dtype == image.dtype
+
+    def test_invert_image_binary(self):
+        """Test image inversion on binary image"""
+        image = np.array([[0, 1], [1, 0]], dtype=np.uint8)
+
+        result = invert_image(image)
+        # skimage.util.invert inverts all bits, so 0->255, 1->254 for uint8
+        expected = np.array([[255, 254], [254, 255]], dtype=np.uint8)
+        np.testing.assert_array_equal(result, expected)
+
+    def test_invert_image_3d(self):
+        """Test image inversion on 3D image"""
+        image = np.random.rand(20, 20, 20)
+
+        result = invert_image(image)
+        assert result.shape == image.shape
+        assert result.dtype == image.dtype
+
+    def test_simple_thresholding_returns_uint32(self):
+        """Test that manual thresholding returns uint8 with value 255 for proper display"""
+        image = np.array([[0, 100, 200], [50, 150, 255]], dtype=np.uint8)
+
+        result = simple_thresholding(image, threshold=128)
+
+        # Check dtype is uint8
+        assert result.dtype == np.uint8
+
+        # Check values are binary (0 or 255)
+        assert set(np.unique(result)).issubset({0, 255})
+
+        # Check correct thresholding
+        expected = np.array([[0, 0, 255], [0, 255, 255]], dtype=np.uint8)
+        np.testing.assert_array_equal(result, expected)
+
+    def test_simple_thresholding_different_thresholds(self):
+        """Test manual thresholding with different threshold values"""
+        image = np.arange(0, 256, dtype=np.uint8).reshape(16, 16)
+
+        # Test with low threshold
+        result_low = simple_thresholding(image, threshold=50)
+        assert result_low.dtype == np.uint8
+        assert (
+            np.sum(result_low == 255) > np.prod(result_low.shape) * 0.8
+        )  # Most pixels above 50
+
+        # Test with high threshold
+        result_high = simple_thresholding(image, threshold=200)
+        assert result_high.dtype == np.uint8
+        assert (
+            np.sum(result_high == 255) < np.prod(result_high.shape) * 0.3
+        )  # Most pixels below 200
+
+
+class TestBrightRegionExtraction:
+    """Test suite for bright region extraction functions"""
+
+    def test_percentile_threshold_original(self):
+        """Test percentile thresholding with original values"""
+        # Create image with gradient
+        image = np.arange(0, 256, dtype=np.uint8).reshape(16, 16)
+
+        result = percentile_threshold(
+            image, percentile=90, output_type="original"
+        )
+
+        # Only top 10% should remain
+        assert result.shape == image.shape
+        assert np.sum(result > 0) < image.size * 0.15  # Allow some margin
+        assert result.max() == image.max()  # Original max value preserved
+
+    def test_percentile_threshold_binary(self):
+        """Test percentile thresholding with binary output"""
+        image = np.random.randint(0, 256, size=(50, 50), dtype=np.uint8)
+
+        result = percentile_threshold(
+            image, percentile=80, output_type="binary"
+        )
+
+        # Should be binary
+        assert result.dtype == np.uint8
+        assert set(np.unique(result)).issubset({0, 255})
+
+    def test_rolling_ball_background_subtraction(self):
+        """Test rolling ball background subtraction"""
+        # Create image with uneven background and bright spot
+        x, y = np.meshgrid(np.arange(100), np.arange(100))
+        background = (50 + 30 * np.sin(x / 20) + 30 * np.sin(y / 20)).astype(
+            np.uint8
+        )
+        image = background.copy()
+        image[40:60, 40:60] += 150  # Add bright feature
+
+        result = rolling_ball_background(image, radius=30)
+
+        # Background should be reduced
+        assert result.shape == image.shape
+        # Center of bright spot should be brighter in result than in corners
+        assert result[50, 50] > result[10, 10]
+
+    def test_adaptive_threshold_bright(self):
+        """Test adaptive thresholding with bright bias"""
+        # Create image with varying brightness
+        image = np.random.randint(0, 256, size=(100, 100), dtype=np.uint8)
+
+        result = adaptive_threshold_bright(image, block_size=35, offset=-10.0)
+
+        # Should be binary
+        assert result.dtype == np.uint8
+        assert set(np.unique(result)).issubset({0, 255})
+        assert result.shape == image.shape
+
+    def test_adaptive_threshold_even_blocksize(self):
+        """Test that even block size is handled correctly"""
+        image = np.random.randint(0, 256, size=(50, 50), dtype=np.uint8)
+
+        # Should handle even block size by making it odd
+        result = adaptive_threshold_bright(image, block_size=34, offset=0)
+
+        assert result.shape == image.shape
+        assert result.dtype == np.uint8
+
+
+class TestCLAHE:
+    """Test suite for CLAHE (Contrast Limited Adaptive Histogram Equalization)"""
+
+    def test_clahe_basic(self):
+        """Test basic CLAHE functionality"""
+        # Create a dark image with weak bright features
+        image = np.zeros((100, 100), dtype=np.float32)
+        image[40:60, 40:60] = 0.1  # Weak bright region
+
+        result = equalize_histogram(image)
+
+        # Output should be same shape
+        assert result.shape == image.shape
+        # Output should be normalized to [0, 1] range
+        assert result.min() >= 0
+        assert result.max() <= 1
+        # Contrast should be enhanced (std deviation should increase)
+        assert result.std() > image.std()
+
+    def test_clahe_dark_with_membranes(self):
+        """Test CLAHE on dark images with weak bright membranes (the use case that failed)"""
+        # Create a realistic dark image with weak membrane-like structures
+        np.random.seed(42)
+        image = np.random.normal(0.05, 0.01, (200, 200))  # Dark background
+        image = np.clip(image, 0, 1)
+
+        # Add weak membrane-like structures
+        image[50:55, :] += 0.1  # Horizontal membrane
+        image[:, 100:105] += 0.1  # Vertical membrane
+        image = np.clip(image, 0, 1)
+
+        result = equalize_histogram(image, clip_limit=0.01)
+
+        # Should not produce black image
+        assert result.max() > 0.1, "CLAHE should not produce near-black images"
+        # Should enhance contrast
+        assert result.std() > image.std()
+        # Membranes should be more visible (higher values)
+        membrane_region = result[50:55, :]
+        background_region = result[10:20, 10:20]
+        assert membrane_region.mean() > background_region.mean()
+
+    def test_clahe_custom_kernel_size(self):
+        """Test CLAHE with custom kernel size"""
+        image = np.random.rand(256, 256)
+
+        result = equalize_histogram(image, kernel_size=64)
+
+        assert result.shape == image.shape
+        assert result.min() >= 0
+        assert result.max() <= 1
+
+    def test_clahe_auto_kernel_size(self):
+        """Test CLAHE with automatic kernel size calculation"""
+        # Small image
+        small_image = np.random.rand(128, 128)
+        result_small = equalize_histogram(small_image, kernel_size=0)
+        assert result_small.shape == small_image.shape
+
+        # Large image
+        large_image = np.random.rand(1024, 1024)
+        result_large = equalize_histogram(large_image, kernel_size=0)
+        assert result_large.shape == large_image.shape
+
+    def test_clahe_different_clip_limits(self):
+        """Test CLAHE with different clip limit values"""
+        image = np.random.rand(100, 100) * 0.2  # Dark image
+
+        # Low clip limit (less contrast enhancement)
+        result_low = equalize_histogram(image, clip_limit=0.005)
+
+        # High clip limit (more contrast enhancement)
+        result_high = equalize_histogram(image, clip_limit=0.05)
+
+        # Both should enhance contrast compared to original
+        assert result_low.std() > image.std()
+        assert result_high.std() > image.std()
+        # Higher clip limit typically gives more contrast (but not always guaranteed)
+        assert (
+            result_high.max() >= result_low.max() * 0.8
+        )  # Allow some tolerance
+
+    def test_clahe_3d_image(self):
+        """Test CLAHE on 3D image (should work on last 2 dimensions)"""
+        # Create 3D image (e.g., time series or z-stack)
+        image_3d = np.random.rand(10, 100, 100) * 0.3
+
+        result = equalize_histogram(image_3d)
+
+        assert result.shape == image_3d.shape
+        # Each slice should be enhanced independently
+        assert result.std() > image_3d.std()
+
+    def test_clahe_preserves_dtype(self):
+        """Test that CLAHE preserves the original dtype"""
+        # Test uint8
+        img_uint8 = np.random.randint(0, 256, (100, 100), dtype=np.uint8)
+        result_uint8 = equalize_histogram(img_uint8)
+        assert result_uint8.dtype == np.uint8
+        assert result_uint8.max() <= 255
+        assert result_uint8.min() >= 0
+
+        # Test uint16
+        img_uint16 = np.random.randint(0, 65536, (100, 100), dtype=np.uint16)
+        result_uint16 = equalize_histogram(img_uint16)
+        assert result_uint16.dtype == np.uint16
+        assert result_uint16.max() <= 65535
+
+        # Test float32
+        img_float32 = np.random.rand(100, 100).astype(np.float32)
+        result_float32 = equalize_histogram(img_float32)
+        assert result_float32.dtype == np.float32
+        assert result_float32.max() <= 1.0
+        assert result_float32.min() >= 0.0

napari_tmidas/_tests/test_split_channels.py

@@ -0,0 +1,217 @@
+"""Test for split_channels function with various image formats"""
+
+import os
+import sys
+
+import numpy as np
+import pytest
+
+# Add the source directory to the path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", ".."))
+
+from napari_tmidas.processing_functions.basic import split_channels
+
+
+class TestSplitChannels:
+    """Test the split_channels function with various input formats"""
+
+    def test_split_tcyx_python_format(self):
+        """Test splitting TCYX image (Time, Channel, Y, X) with python format"""
+        # Create a TCYX image: 5 timepoints, 3 channels, 100x100 pixels
+        tcyx_image = np.random.rand(5, 3, 100, 100)
+
+        result = split_channels(
+            tcyx_image, num_channels=3, time_steps=5, output_format="python"
+        )
+
+        # Result should be (3, 5, 100, 100): 3 channels, each with shape (5, 100, 100)
+        assert result.shape == (
+            3,
+            5,
+            100,
+            100,
+        ), f"Expected shape (3, 5, 100, 100), got {result.shape}"
+
+        # Each channel should have shape (5, 100, 100)
+        for i in range(3):
+            assert result[i].shape == (
+                5,
+                100,
+                100,
+            ), f"Channel {i} has incorrect shape {result[i].shape}"
+
+    def test_split_tcyx_fiji_format(self):
+        """Test splitting TCYX image with Fiji format"""
+        # Create a TCYX image: 5 timepoints, 3 channels, 100x100 pixels
+        tcyx_image = np.random.rand(5, 3, 100, 100)
+
+        result = split_channels(
+            tcyx_image, num_channels=3, time_steps=5, output_format="fiji"
+        )
+
+        # Result should be (3, 5, 100, 100): 3 channels, each with shape (5, 100, 100)
+        assert result.shape == (
+            3,
+            5,
+            100,
+            100,
+        ), f"Expected shape (3, 5, 100, 100), got {result.shape}"
+
+        # Each channel should have shape (5, 100, 100)
+        for i in range(3):
+            assert result[i].shape == (
+                5,
+                100,
+                100,
+            ), f"Channel {i} has incorrect shape {result[i].shape}"
+
+    def test_split_yxc_image(self):
+        """Test splitting standard RGB image (YXC)"""
+        # Create a YXC image: 100x100 pixels, 3 channels
+        yxc_image = np.random.rand(100, 100, 3)
+
+        result = split_channels(
+            yxc_image, num_channels=3, time_steps=0, output_format="python"
+        )
+
+        # Result should be (3, 100, 100): 3 channels, each with shape (100, 100)
+        assert result.shape == (
+            3,
+            100,
+            100,
+        ), f"Expected shape (3, 100, 100), got {result.shape}"
+
+        # Each channel should have shape (100, 100)
+        for i in range(3):
+            assert result[i].shape == (
+                100,
+                100,
+            ), f"Channel {i} has incorrect shape {result[i].shape}"
+
+    def test_split_zyxc_image(self):
+        """Test splitting 3D color image (ZYXC)"""
+        # Create a ZYXC image: 10 z-slices, 100x100 pixels, 3 channels
+        zyxc_image = np.random.rand(10, 100, 100, 3)
+
+        result = split_channels(
+            zyxc_image, num_channels=3, time_steps=0, output_format="python"
+        )
+
+        # Result should be (3, 10, 100, 100): 3 channels, each with shape (10, 100, 100)
+        assert result.shape == (
+            3,
+            10,
+            100,
+            100,
+        ), f"Expected shape (3, 10, 100, 100), got {result.shape}"
+
+        # Each channel should have shape (10, 100, 100)
+        for i in range(3):
+            assert result[i].shape == (
+                10,
+                100,
+                100,
+            ), f"Channel {i} has incorrect shape {result[i].shape}"
+
+    def test_split_tzyxc_image(self):
+        """Test splitting 4D time-series color Z-stack (TZYXC)"""
+        # Create a TZYXC image: 5 timepoints, 10 z-slices, 100x100 pixels, 3 channels
+        tzyxc_image = np.random.rand(5, 10, 100, 100, 3)
+
+        result = split_channels(
+            tzyxc_image, num_channels=3, time_steps=5, output_format="python"
+        )
+
+        # Result should be (3, 5, 10, 100, 100): 3 channels, each with shape (5, 10, 100, 100)
+        assert result.shape == (
+            3,
+            5,
+            10,
+            100,
+            100,
+        ), f"Expected shape (3, 5, 10, 100, 100), got {result.shape}"
+
+        # Each channel should have shape (5, 10, 100, 100)
+        for i in range(3):
+            assert result[i].shape == (
+                5,
+                10,
+                100,
+                100,
+            ), f"Channel {i} has incorrect shape {result[i].shape}"
+
+    def test_split_channels_with_4_channels(self):
+        """Test splitting image with 4 channels (RGBA)"""
+        # Create a YXC image: 100x100 pixels, 4 channels
+        yxc_image = np.random.rand(100, 100, 4)
+
+        result = split_channels(
+            yxc_image, num_channels=4, time_steps=0, output_format="python"
+        )
+
+        # Result should be (4, 100, 100): 4 channels, each with shape (100, 100)
+        assert result.shape == (
+            4,
+            100,
+            100,
+        ), f"Expected shape (4, 100, 100), got {result.shape}"
+
+        # Each channel should have shape (100, 100)
+        for i in range(4):
+            assert result[i].shape == (
+                100,
+                100,
+            ), f"Channel {i} has incorrect shape {result[i].shape}"
+
+    def test_split_channels_verifies_data_integrity(self):
+        """Test that split channels contain the correct data"""
+        # Create a simple test image where we can verify the data
+        tcyx_image = np.zeros((2, 3, 10, 10))  # 2 timepoints, 3 channels
+
+        # Set distinct values for each channel
+        tcyx_image[:, 0, :, :] = 1.0  # Channel 0
+        tcyx_image[:, 1, :, :] = 2.0  # Channel 1
+        tcyx_image[:, 2, :, :] = 3.0  # Channel 2
+
+        result = split_channels(
+            tcyx_image, num_channels=3, time_steps=2, output_format="python"
+        )
+
+        # Verify shape
+        assert result.shape == (3, 2, 10, 10)
+
+        # Verify data integrity
+        assert np.allclose(result[0], 1.0), "Channel 0 data incorrect"
+        assert np.allclose(result[1], 2.0), "Channel 1 data incorrect"
+        assert np.allclose(result[2], 3.0), "Channel 2 data incorrect"
+
+    def test_split_channels_auto_detect_mismatch(self):
+        """Test that function handles mismatch between specified and actual channel count"""
+        # Create a TCYX image: 5 timepoints, 4 channels, 100x100 pixels
+        tcyx_image = np.random.rand(5, 4, 100, 100)
+
+        # Specify 3 channels when there are actually 4
+        result = split_channels(
+            tcyx_image, num_channels=3, time_steps=5, output_format="python"
+        )
+
+        # Should auto-detect and use 4 channels
+        assert result.shape == (
+            4,
+            5,
+            100,
+            100,
+        ), f"Expected shape (4, 5, 100, 100), got {result.shape}"
+
+    def test_split_channels_dimension_error(self):
+        """Test that function raises error for invalid input"""
+        # Create a 2D image (should fail)
+        image_2d = np.random.rand(100, 100)
+
+        with pytest.raises(ValueError, match="at least 3 dimensions"):
+            split_channels(image_2d, num_channels=3, time_steps=0)
+
+
+if __name__ == "__main__":
+    # Run tests with pytest
+    pytest.main([__file__, "-v"])