added mask resize processing function

Author: macromeer

src/napari_tmidas/_tests/test_skimage_filters.py

@@ -3,16 +3,28 @@
 
 from napari_tmidas.processing_functions.skimage_filters import (
     adaptive_threshold_bright,
-    h_maxima_transform,
     invert_image,
     percentile_threshold,
+    resize_mask,
     rolling_ball_background,
     simple_thresholding,
     white_tophat,
 )
 
 
 class TestSkimageFilters:
+    def test_resize_mask_nearest(self):
+        """Test resizing a mask with nearest-neighbor interpolation preserves mask integrity."""
+        mask = np.zeros((10, 10), dtype=np.uint8)
+        mask[2:8, 2:8] = 1
+        output_shape = (20, 20)
+        resized = resize_mask(mask, output_shape=output_shape)
+        assert resized.shape == output_shape
+        # Should only contain 0 and 1
+        assert set(np.unique(resized)).issubset({0, 1})
+        # Check that the central region is still 1
+        assert np.sum(resized == 1) > 0
+
     def test_invert_image_basic(self):
         """Test basic image inversion functionality"""
         image = np.random.rand(100, 100)
@@ -134,21 +146,6 @@ def test_rolling_ball_background_subtraction(self):
         # Center of bright spot should be brighter in result than in corners
         assert result[50, 50] > result[10, 10]
 
-    def test_h_maxima_transform(self):
-        """Test H-maxima transform suppresses small peaks"""
-        # Create image with peaks of different heights
-        image = np.zeros((100, 100), dtype=np.uint8)
-        image[20, 20] = 100  # Small peak
-        image[50, 50] = 200  # Large peak
-        image[80, 80] = 80  # Very small peak
-
-        result = h_maxima_transform(image, h=50.0)
-
-        # Should suppress small peaks, keep large ones
-        assert result.shape == image.shape
-        # Large peak should remain prominent
-        assert result[50, 50] > result[20, 20]
-
     def test_adaptive_threshold_bright(self):
         """Test adaptive thresholding with bright bias"""
         # Create image with varying brightness

src/napari_tmidas/processing_functions/skimage_filters.py

@@ -33,6 +33,37 @@
 
 if SKIMAGE_AVAILABLE:
 
+    @BatchProcessingRegistry.register(
+        name="Resize Mask (Nearest)",
+        suffix="_resized",
+        description="Resize a mask using nearest-neighbor interpolation (order=0, anti_aliasing=False) to preserve mask integrity.",
+        parameters={
+            "output_shape": {
+                "type": "tuple",
+                "default": None,
+                "description": "Desired output shape as a tuple (e.g., (height, width)). If None, no resizing is performed.",
+            },
+        },
+    )
+    def resize_mask(mask: np.ndarray, output_shape=None) -> np.ndarray:
+        """
+        Resize a mask using nearest-neighbor interpolation to preserve mask integrity.
+        Uses skimage.transform.resize with order=0 and anti_aliasing=False.
+        """
+        if output_shape is None:
+            return mask
+        from skimage.transform import resize
+
+        resized = resize(
+            mask,
+            output_shape,
+            order=0,
+            preserve_range=True,
+            anti_aliasing=False,
+        )
+        # Ensure integer type for mask
+        return resized.astype(mask.dtype)
+
     # Equalize histogram
     @BatchProcessingRegistry.register(
         name="Equalize Histogram",
@@ -646,46 +677,6 @@ def rolling_ball_background(
 
         return result
 
-    @BatchProcessingRegistry.register(
-        name="H-Maxima Transform",
-        suffix="_hmaxima",
-        description="Suppress all maxima with height less than h (keeps only prominent bright peaks)",
-        parameters={
-            "h": {
-                "type": float,
-                "default": 10.0,
-                "min": 0.1,
-                "max": 255.0,
-                "description": "Height threshold (suppress maxima smaller than this)",
-            }
-        },
-    )
-    def h_maxima_transform(image: np.ndarray, h: float = 10.0) -> np.ndarray:
-        """
-        Apply H-maxima transform to extract prominent bright peaks.
-
-        The H-maxima transform suppresses all local maxima whose height
-        (difference from surrounding pixels) is less than h. This is excellent
-        for finding bright spots and peaks while ignoring small intensity
-        variations.
-
-        Parameters:
-        -----------
-        image : numpy.ndarray
-            Input image array
-        h : float
-            Height threshold. Local maxima with peak height less than h
-            will be suppressed. Larger values keep only more prominent peaks.
-
-        Returns:
-        --------
-        numpy.ndarray
-            Image with only prominent bright peaks preserved
-        """
-        from skimage.morphology import h_maxima
-
-        return h_maxima(image, h=h)
-
     @BatchProcessingRegistry.register(
         name="Adaptive Threshold (Bright Bias)",
         suffix="_adaptive_bright",