Merge branch 'main' of https://github.com/macromeer/napari-tmidas

Author: macromeer

src/napari_tmidas/_file_selector.py

@@ -175,36 +175,26 @@ def Signal(*args):
     )
 
 
-def is_label_image(filename: str) -> bool:
+def is_label_image(image: np.ndarray) -> bool:
     """
-    Determine if a file should be treated as a label image based on its filename.
+    Determine if an image should be treated as a label image based on its dtype.
 
-    This function checks for common suffixes used by processing functions that
-    produce label or binary mask outputs.
+    This function uses the same logic as Napari's guess_labels() function,
+    checking if the dtype is one of the integer types commonly used for labels.
 
     Parameters:
     -----------
-    filename : str
-        The filename (or full path) to check
+    image : np.ndarray
+        The image array to check
 
     Returns:
     --------
     bool
-        True if the file should be treated as labels, False otherwise
+        True if the image dtype suggests it's a label image, False otherwise
     """
-    label_suffixes = [
-        "labels",
-        "semantic",
-        "_binary",
-        "_inverted",
-        "_thresh",
-        "_otsu_semantic",
-        "_otsu_labels",
-        "_instance",
-        "_rm_small",
-    ]
-    filename_lower = filename.lower()
-    return any(suffix in filename_lower for suffix in label_suffixes)
+    if hasattr(image, "dtype"):
+        return image.dtype in (np.int32, np.uint32, np.int64, np.uint64)
+    return False
 
 
 def load_zarr_with_napari_ome_zarr(
@@ -873,8 +863,8 @@ def _load_original_image(self, filepath: str):
 
             # Single channel image
             base_filename = os.path.basename(filepath)
-            # check if label image by checking file name for label-related suffixes
-            is_label = is_label_image(base_filename)
+            # check if label image by checking image dtype
+            is_label = is_label_image(image)
 
             if is_label:
                 if hasattr(image, "astype"):
@@ -1241,8 +1231,8 @@ def _load_processed_image(self, filepath: str):
 
             # Single channel processed image
             filename = os.path.basename(filepath)
-            # Check if filename contains label indicators
-            is_label = is_label_image(filename)
+            # Check if image dtype indicates labels
+            is_label = is_label_image(image)
 
             # Add the layer using the appropriate method
             if is_label:
@@ -1671,7 +1661,11 @@ def process_file(self, filepath):
                     len(processed_result) == 3
                     and self.output_suffix == "_layer"
                 ):
-                    layer_names = ["_inner", "_middle", "_outer"]
+                    layer_names = [
+                        "_inner",
+                        "_middle",
+                        "_outer",
+                    ]
                     for idx, (img, layer_name) in enumerate(
                         zip(processed_result, layer_names)
                     ):
@@ -1705,37 +1699,19 @@ def process_file(self, filepath):
                         # For very large files, use BigTIFF format
                         use_bigtiff = size_gb > 2.0
 
-                        # Check if this is a label image
-                        is_label = is_label_image(output_filename)
-
-                        if is_label:
-                            # Choose appropriate integer type based on data range
-                            if data_max <= 255:
-                                save_dtype = np.uint8
-                            elif data_max <= 65535:
-                                save_dtype = np.uint16
-                            else:
-                                save_dtype = np.uint32
+                        # Layer subdivision outputs should always be saved as uint32
+                        # to ensure Napari auto-detects them as labels
+                        save_dtype = np.uint32
 
-                            print(
-                                f"Label image detected, saving as {save_dtype.__name__} with bigtiff={use_bigtiff}"
-                            )
-                            tifffile.imwrite(
-                                output_path,
-                                img.astype(save_dtype),
-                                compression="zlib",
-                                bigtiff=use_bigtiff,
-                            )
-                        else:
-                            print(
-                                f"Regular image, saving with dtype {image_dtype} and bigtiff={use_bigtiff}"
-                            )
-                            tifffile.imwrite(
-                                output_path,
-                                img.astype(image_dtype),
-                                compression="zlib",
-                                bigtiff=use_bigtiff,
-                            )
+                        print(
+                            f"Saving layer {layer_name} as {save_dtype.__name__} with bigtiff={use_bigtiff}"
+                        )
+                        tifffile.imwrite(
+                            output_path,
+                            img.astype(save_dtype),
+                            compression="zlib",
+                            bigtiff=use_bigtiff,
+                        )
 
                         processed_files.append(output_path)
                 else:
@@ -1771,17 +1747,13 @@ def process_file(self, filepath):
                         # For very large files, use BigTIFF format
                         use_bigtiff = size_gb > 2.0
 
-                        # Check if this is a label image
-                        is_label = is_label_image(output_filename)
+                        # Check if this is a label image based on dtype
+                        is_label = is_label_image(img)
 
                         if is_label:
-                            # Choose appropriate integer type based on data range
-                            if data_max <= 255:
-                                save_dtype = np.uint8
-                            elif data_max <= 65535:
-                                save_dtype = np.uint16
-                            else:
-                                save_dtype = np.uint32
+                            # For labels, always use uint32 to ensure Napari recognizes them
+                            # Napari auto-detects labels based on dtype (int32/uint32/int64/uint64)
+                            save_dtype = np.uint32
 
                             print(
                                 f"Label image detected, saving as {save_dtype.__name__} with bigtiff={use_bigtiff}"
@@ -1906,17 +1878,13 @@ def process_file(self, filepath):
                     # For very large files, use BigTIFF format
                     use_bigtiff = size_gb > 2.0
 
-                    # Check if this is a label image by checking filename
-                    is_label = is_label_image(channel_filename)
+                    # Check if this is a label image based on dtype
+                    is_label = is_label_image(channel_image)
 
                     if is_label:
-                        # Choose appropriate integer type based on data range
-                        if data_max <= 255:
-                            save_dtype = np.uint8
-                        elif data_max <= 65535:
-                            save_dtype = np.uint16
-                        else:
-                            save_dtype = np.uint32
+                        # For labels, always use uint32 to ensure Napari recognizes them
+                        # Napari auto-detects labels based on dtype (int32/uint32/int64/uint64)
+                        save_dtype = np.uint32
 
                         print(
                             f"Label image detected, saving as {save_dtype.__name__} with bigtiff={use_bigtiff}"
@@ -1970,8 +1938,8 @@ def process_file(self, filepath):
                 )
                 print(f"Data range: {data_min} to {data_max}")
 
-                # Check if this is a label image by checking filename
-                is_label = is_label_image(new_filename_base)
+                # Check if this is a label image based on dtype
+                is_label = is_label_image(processed_image)
 
                 if is_label:
                     save_dtype = np.uint32

src/napari_tmidas/_processing_worker.py

@@ -178,7 +178,11 @@ def process_file(self, filepath):
                     len(processed_image) == 3
                     and self.output_suffix == "_layer"
                 ):
-                    layer_names = ["_inner", "_middle", "_outer"]
+                    layer_names = [
+                        "_inner",
+                        "_middle",
+                        "_outer",
+                    ]
                     for img, layer_name in zip(processed_image, layer_names):
                         if not isinstance(img, np.ndarray):
                             continue
@@ -189,8 +193,8 @@ def process_file(self, filepath):
                             self.output_folder, output_filename
                         )
 
-                        # Save the processed image
-                        save_image_file(img, output_path, image_dtype)
+                        # Save as uint32 to ensure Napari auto-detects as labels
+                        save_image_file(img, output_path, np.uint32)
                         processed_files.append(output_path)
                 else:
                     # Default behavior for other multi-output functions (e.g., channel splitting)
@@ -253,23 +257,16 @@ def load_image_file(filepath: str) -> Union[np.ndarray, List, Any]:
     return np.random.rand(100, 100)
 
 
-def is_label_image(filename: str) -> bool:
-    """Check if filename indicates a label image"""
-    label_suffixes = [
-        "labels",
-        "semantic",
-        "_binary",
-        "_inverted",
-        "_thresh",
-        "_mask",
-        "_seg",
-        "segmentation",
-        "_inner",
-        "_middle",
-        "_outer",
-    ]
-    filename_lower = filename.lower()
-    return any(suffix in filename_lower for suffix in label_suffixes)
+def is_label_image(image: np.ndarray) -> bool:
+    """
+    Determine if an image should be treated as a label image based on its dtype.
+
+    This function uses the same logic as Napari's guess_labels() function,
+    checking if the dtype is one of the integer types commonly used for labels.
+    """
+    if hasattr(image, "dtype"):
+        return image.dtype in (np.int32, np.uint32, np.int64, np.uint64)
+    return False
 
 
 def save_image_file(image: np.ndarray, filepath: str, dtype=None):
@@ -285,33 +282,20 @@ def save_image_file(image: np.ndarray, filepath: str, dtype=None):
     # For very large files, use BigTIFF format
     use_bigtiff = size_gb > 2.0
 
-    # Check data range
-    data_max = np.max(image) if image.size > 0 else 0
-
-    # Check if this is a label image
-    is_label = is_label_image(filepath)
-
-    if is_label:
-        # Choose appropriate integer type based on data range
-        if data_max <= 255:
-            save_dtype = np.uint8
-        elif data_max <= 65535:
-            save_dtype = np.uint16
-        else:
-            save_dtype = np.uint32
-
-        tifffile.imwrite(
-            filepath,
-            image.astype(save_dtype),
-            compression="zlib",
-            bigtiff=use_bigtiff,
-        )
+    # Determine save dtype
+    if dtype is not None:
+        # Use explicitly provided dtype
+        save_dtype = dtype
+    elif is_label_image(image):
+        # Input is already a label dtype, preserve as uint32
+        save_dtype = np.uint32
     else:
-        # Use provided dtype or image's dtype
-        save_dtype = dtype if dtype is not None else image.dtype
-        tifffile.imwrite(
-            filepath,
-            image.astype(save_dtype),
-            compression="zlib",
-            bigtiff=use_bigtiff,
-        )
+        # Use image's dtype
+        save_dtype = image.dtype
+
+    tifffile.imwrite(
+        filepath,
+        image.astype(save_dtype),
+        compression="zlib",
+        bigtiff=use_bigtiff,
+    )

src/napari_tmidas/_reader.py

@@ -1,9 +1,5 @@
 """
-This module is an example of a barebones numpy reader plugin for napari.
-
-It implements the Reader specification, but your plugin may choose to
-implement multiple readers or even other plugin contributions. see:
-https://napari.org/stable/plugins/guides.html?#readers
+This module implements a reader plugin for napari.
 """
 
 import numpy as np
@@ -29,12 +25,12 @@ def napari_get_reader(path):
         # so we are only going to look at the first file.
         path = path[0]
 
-    # if we know we cannot read the file, we immediately return None.
-    if not path.endswith(".npy"):
-        return None
+    # Support .npy files
+    if path.endswith(".npy"):
+        return reader_function
 
-    # otherwise we return the *function* that can read ``path``.
-    return reader_function
+    # if we know we cannot read the file, we immediately return None.
+    return None
 
 
 def reader_function(path):

src/napari_tmidas/processing_functions/scipy_filters.py

@@ -93,17 +93,17 @@ def resize_labels(
     @BatchProcessingRegistry.register(
         name="Subdivide Labels into 3 Layers",
         suffix="_layer",
-        description="Subdivide each labeled object into 3 concentric layers of equal thickness (inner core, middle shell, outer shell). Each layer is saved as a separate file with _inner, _middle, and _outer suffixes.",
+        description="Subdivide each labeled object into 3 concentric layers of equal thickness (inner core, middle shell, outer shell). Each layer is saved as a separate file with _inner_labels, _middle_labels, and _outer_labels suffixes.",
         parameters={},
     )
     def subdivide_labels_3layers(label_image: np.ndarray) -> tuple:
         """
         Subdivide labeled objects into 3 concentric layers of equal thickness.
 
         Creates three separate label images representing:
-        - Layer 1 (innermost): Core region at ~33% scale (saved as *_inner.tif)
-        - Layer 2 (middle): Shell between ~33% and ~67% scale (saved as *_middle.tif)
-        - Layer 3 (outermost): Shell between ~67% and 100% scale (saved as *_outer.tif)
+        - Layer 1 (innermost): Core region at ~33% scale (saved as *_inner_labels.tif)
+        - Layer 2 (middle): Shell between ~33% and ~67% scale (saved as *_middle_labels.tif)
+        - Layer 3 (outermost): Shell between ~67% and 100% scale (saved as *_outer_labels.tif)
 
         Parameters
         ----------