Add filter_label_by_id function and sort processing functions alphabetically

- Add new 'Filter Label by ID' processing function to keep only a specified label ID and set all others to background
- Implement using np.where for clean, idiomatic NumPy code
- Sort processing functions dropdown alphabetically in BatchProcessingRegistry.list_functions()
- Add comprehensive test coverage with 6 test cases for the new filter function

Author: macromeer

src/napari_tmidas/_registry.py

@@ -64,6 +64,6 @@ def get_function_info(cls, name: str) -> Optional[dict]:
 
     @classmethod
     def list_functions(cls) -> List[str]:
-        """Thread-safe listing"""
+        """Thread-safe listing, returns alphabetically sorted list"""
         with cls._lock:
-            return list(cls._processing_functions.keys())
+            return sorted(cls._processing_functions.keys())

src/napari_tmidas/_tests/test_processing_basic.py

@@ -3,6 +3,7 @@
 import pytest
 
 from napari_tmidas.processing_functions.basic import (
+    filter_label_by_id,
     intersect_label_images,
     invert_binary_labels,
     keep_slice_range_by_area,
@@ -129,6 +130,60 @@ def test_invert_binary_labels_empty(self):
         assert result.shape == (0, 0)
         assert result.dtype == np.uint8
 
+    def test_filter_label_by_id_basic(self):
+        """Test filtering to keep only one label ID"""
+        # Create test label image with multiple labels
+        labels = np.array([[0, 1, 2], [3, 1, 2], [1, 0, 3]], dtype=np.uint32)
+
+        # Keep only label 1
+        result = filter_label_by_id(labels, label_id=1)
+
+        # Check result - only label 1 should remain, others become 0
+        expected = np.array([[0, 1, 0], [0, 1, 0], [1, 0, 0]], dtype=np.uint32)
+        np.testing.assert_array_equal(result, expected)
+        assert result.dtype == labels.dtype
+
+    def test_filter_label_by_id_default_param(self):
+        """Test filtering with default parameter (label_id=1)"""
+        labels = np.array([[0, 1, 2], [1, 2, 0], [2, 0, 1]], dtype=np.uint32)
+        result = filter_label_by_id(labels)
+        expected = np.array([[0, 1, 0], [1, 0, 0], [0, 0, 1]], dtype=np.uint32)
+        np.testing.assert_array_equal(result, expected)
+
+    def test_filter_label_by_id_nonexistent(self):
+        """Test filtering with label ID that doesn't exist"""
+        labels = np.array([[1, 2, 3], [2, 3, 1], [3, 1, 2]], dtype=np.uint32)
+        # Try to keep label 99 which doesn't exist
+        result = filter_label_by_id(labels, label_id=99)
+        # All should become background
+        expected = np.zeros_like(labels)
+        np.testing.assert_array_equal(result, expected)
+
+    def test_filter_label_by_id_3d(self):
+        """Test filtering with 3D label image"""
+        labels = np.array(
+            [[[1, 2], [3, 1]], [[2, 1], [1, 3]]], dtype=np.uint32
+        )
+        result = filter_label_by_id(labels, label_id=2)
+        expected = np.array(
+            [[[0, 2], [0, 0]], [[2, 0], [0, 0]]], dtype=np.uint32
+        )
+        np.testing.assert_array_equal(result, expected)
+
+    def test_filter_label_by_id_all_same(self):
+        """Test filtering when all pixels are the target label"""
+        labels = np.ones((3, 3), dtype=np.uint32) * 5
+        result = filter_label_by_id(labels, label_id=5)
+        # All should remain
+        np.testing.assert_array_equal(result, labels)
+
+    def test_filter_label_by_id_all_background(self):
+        """Test filtering with all background"""
+        labels = np.zeros((3, 3), dtype=np.uint32)
+        result = filter_label_by_id(labels, label_id=1)
+        # Should remain all zeros
+        np.testing.assert_array_equal(result, labels)
+
     def test_mirror_labels_double_size_default_axis(self):
         """Mirroring keeps the same shape and mirrors around largest area slice"""
         image = np.zeros((4, 2, 2), dtype=np.uint16)

src/napari_tmidas/processing_functions/basic.py

@@ -134,6 +134,41 @@ def invert_binary_labels(image: np.ndarray) -> np.ndarray:
     return result
 
 
+@BatchProcessingRegistry.register(
+    name="Filter Label by ID",
+    suffix="_filtered",
+    description="Keep only the specified label ID, set all other labels to background (0)",
+    parameters={
+        "label_id": {
+            "type": int,
+            "default": 1,
+            "min": 1,
+            "description": "Label ID to keep (all others become background)",
+        }
+    },
+)
+def filter_label_by_id(image: np.ndarray, label_id: int = 1) -> np.ndarray:
+    """
+    Filter a label image to keep only the specified label ID.
+    All other label IDs are set to background (0).
+
+    Parameters
+    ----------
+    image : np.ndarray
+        Input label image
+    label_id : int
+        The label ID to keep (default: 1)
+
+    Returns
+    -------
+    np.ndarray
+        Filtered label image with only the specified label ID preserved
+    """
+    arr = _to_array(image)
+    result = np.where(arr == label_id, arr, 0).astype(arr.dtype)
+    return result
+
+
 @BatchProcessingRegistry.register(
     name="Mirror Labels",
     suffix="_mirrored",