added resize_labels processing function

Author: macromeer

src/napari_tmidas/_tests/test_skimage_filters.py

@@ -5,24 +5,31 @@
     adaptive_threshold_bright,
     invert_image,
     percentile_threshold,
-    resize_mask,
     rolling_ball_background,
     simple_thresholding,
 )
 
 
 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_resize_labels(self):
+        """Test resizing a label image by scale factor preserves label values and shape."""
+        from napari_tmidas.processing_functions.skimage_filters import (
+            resize_labels,
+        )
+
+        label_image = np.zeros((10, 10), dtype=np.uint8)
+        label_image[2:8, 2:8] = 3
+        scale_factor = 0.5
+        scaled = resize_labels(label_image, scale_factor=scale_factor)
+        expected_shape = tuple(
+            (np.array(label_image.shape) * scale_factor).astype(int)
+        )
+        assert scaled.shape == expected_shape
+        # Should only contain 0 and 3
+        assert set(np.unique(scaled)).issubset({0, 3})
+        # Check that the central region is still present
+        assert np.sum(scaled == 3) > 0
 
     def test_invert_image_basic(self):
         """Test basic image inversion functionality"""

src/napari_tmidas/processing_functions/skimage_filters.py

@@ -34,35 +34,39 @@
 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.",
+        name="Resize Labels (Nearest)",
+        suffix="_scaled",
+        description="Resize a label mask or label image by a scale factor using nearest-neighbor interpolation (order=0, anti_aliasing=False) to preserve label 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.",
+            "scale_factor": {
+                "type": "float",
+                "default": 1.0,
+                "min": 0.01,
+                "max": 10.0,
+                "description": "Factor by which to resize the label image (e.g., 0.8 for 80% size, 1.2 for 120% size). 1.0 means no resizing.",
             },
         },
     )
-    def resize_mask(mask: np.ndarray, output_shape=None) -> np.ndarray:
+    def resize_labels(label_image: np.ndarray, scale_factor=1.0) -> np.ndarray:
         """
-        Resize a mask using nearest-neighbor interpolation to preserve mask integrity.
-        Uses skimage.transform.resize with order=0 and anti_aliasing=False.
+        Resize a label mask or label image by a scale factor using nearest-neighbor interpolation to preserve label integrity.
         """
-        if output_shape is None:
-            return mask
+        if scale_factor == 1.0:
+            return label_image
+        import numpy as np
         from skimage.transform import resize
 
-        resized = resize(
-            mask,
-            output_shape,
+        new_shape = tuple(
+            (np.array(label_image.shape) * scale_factor).astype(int)
+        )
+        scaled_labels = resize(
+            label_image,
+            new_shape,
             order=0,
             preserve_range=True,
             anti_aliasing=False,
-        )
-        # Ensure integer type for mask
-        return resized.astype(mask.dtype)
+        ).astype(label_image.dtype)
+        return scaled_labels
 
     # Equalize histogram
     @BatchProcessingRegistry.register(