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

napari_tmidas/_file_selector.py

@@ -10,43 +10,448 @@ New functions can be added to the processing registry by decorating them with
 as the first argument, and any additional keyword arguments for parameters.
 """
 
+from __future__ import annotations
+
 import concurrent.futures
 import os
 import sys
-from typing import Any, Dict, List
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, Union
 
-import napari
 import numpy as np
-import tifffile
-from magicgui import magicgui
-from qtpy.QtCore import Qt, QThread, Signal
-from qtpy.QtWidgets import (
-    QComboBox,
-    QDoubleSpinBox,
-    QFileDialog,
-    QFormLayout,
-    QHBoxLayout,
-    QHeaderView,
-    QLabel,
-    QLineEdit,
-    QProgressBar,
-    QPushButton,
-    QSpinBox,
-    QTableWidget,
-    QTableWidgetItem,
-    QVBoxLayout,
-    QWidget,
-)
-from skimage.io import imread
+
+# Lazy imports for optional heavy dependencies
+if TYPE_CHECKING:
+    import napari
+    import tifffile
+    import zarr
+    from magicgui import magicgui
+    from qtpy.QtCore import Qt, QThread, Signal
+    from qtpy.QtWidgets import (
+        QCheckBox,
+        QComboBox,
+        QDoubleSpinBox,
+        QFormLayout,
+        QHBoxLayout,
+        QHeaderView,
+        QLabel,
+        QLineEdit,
+        QProgressBar,
+        QPushButton,
+        QSpinBox,
+        QTableWidget,
+        QTableWidgetItem,
+        QVBoxLayout,
+        QWidget,
+    )
+    from skimage.io import imread
+
+try:
+    import napari
+
+    _HAS_NAPARI = True
+except ImportError:
+    napari = None
+    _HAS_NAPARI = False
+
+try:
+    import tifffile
+
+    _HAS_TIFFFILE = True
+except ImportError:
+    tifffile = None
+    _HAS_TIFFFILE = False
+
+try:
+    import zarr
+
+    _HAS_ZARR = True
+except ImportError:
+    zarr = None
+    _HAS_ZARR = False
+
+try:
+    from magicgui import magicgui
+
+    _HAS_MAGICGUI = True
+except ImportError:
+    # Create stub decorator
+    def magicgui(*args, **kwargs):
+        def decorator(func):
+            return func
+
+        if len(args) == 1 and callable(args[0]) and not kwargs:
+            return args[0]
+        return decorator
+
+    _HAS_MAGICGUI = False
+
+try:
+    from qtpy.QtCore import Qt, QThread, Signal
+    from qtpy.QtWidgets import (
+        QCheckBox,
+        QComboBox,
+        QDoubleSpinBox,
+        QFormLayout,
+        QHBoxLayout,
+        QHeaderView,
+        QLabel,
+        QLineEdit,
+        QMessageBox,
+        QProgressBar,
+        QPushButton,
+        QSpinBox,
+        QTableWidget,
+        QTableWidgetItem,
+        QVBoxLayout,
+        QWidget,
+    )
+
+    _HAS_QTPY = True
+except ImportError:
+    Qt = QThread = Signal = None
+    QCheckBox = QComboBox = QDoubleSpinBox = QFormLayout = QHBoxLayout = None
+    QHeaderView = QLabel = QLineEdit = QMessageBox = QProgressBar = (
+        QPushButton
+    ) = None
+    QSpinBox = QTableWidget = QTableWidgetItem = QVBoxLayout = QWidget = None
+    _HAS_QTPY = False
+
+try:
+    from skimage.io import imread
+
+    _HAS_SKIMAGE = True
+except ImportError:
+    imread = None
+    _HAS_SKIMAGE = False
+
+# Create stub base classes when dependencies are missing
+if not _HAS_QTPY:
+    # Create minimal stubs to allow class definitions
+    class QTableWidget:
+        pass
+
+    class QThread:
+        pass
+
+    class QWidget:
+        pass
+
+    def Signal(*args):
+        return None
+
 
 # Import registry and processing functions
 from napari_tmidas._registry import BatchProcessingRegistry
+from napari_tmidas._ui_utils import add_browse_button_to_folder_field
 
 sys.path.append("src/napari_tmidas")
 from napari_tmidas.processing_functions import (
     discover_and_load_processing_functions,
 )
 
+# Import cancellation functions for subprocess-based processing
+try:
+    from napari_tmidas.processing_functions.cellpose_env_manager import (
+        cancel_cellpose_processing,
+    )
+except ImportError:
+    cancel_cellpose_processing = None
+
+# Check for OME-Zarr support
+try:
+    from napari_ome_zarr import napari_get_reader
+
+    OME_ZARR_AVAILABLE = True
+    print("napari-ome-zarr found - enhanced Zarr support enabled")
+except ImportError:
+    OME_ZARR_AVAILABLE = False
+    print(
+        "Tip: Install napari-ome-zarr for better Zarr support: pip install napari-ome-zarr"
+    )
+
+try:
+    import dask.array as da
+
+    DASK_AVAILABLE = True
+except ImportError:
+    DASK_AVAILABLE = False
+    print(
+        "Tip: Install dask for better performance with large datasets: pip install dask"
+    )
+
+
+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.
+
+    Parameters:
+    -----------
+    image : np.ndarray
+        The image array to check
+
+    Returns:
+    --------
+    bool
+        True if the image dtype suggests it's a label image, False otherwise
+    """
+    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(
+    filepath: str, verbose: bool = True
+) -> Optional[List[Tuple]]:
+    """
+    Load zarr using napari-ome-zarr reader with enhanced error handling
+    """
+    if not OME_ZARR_AVAILABLE:
+        return None
+
+    try:
+        # Try multiple approaches to get the reader
+        reader_func = napari_get_reader(filepath)
+        if reader_func is None:
+            if verbose:
+                print(f"napari-ome-zarr: No reader available for {filepath}")
+            return None
+
+        # Try to read the data
+        layer_data_list = reader_func(filepath)
+
+        if layer_data_list and len(layer_data_list) > 0:
+            if verbose:
+                print(
+                    f"napari-ome-zarr: Successfully loaded {len(layer_data_list)} layers"
+                )
+
+            # Enhance layer metadata
+            enhanced_layers = []
+            for i, (data, add_kwargs, layer_type) in enumerate(
+                layer_data_list
+            ):
+                # Ensure proper naming
+                if "name" not in add_kwargs or not add_kwargs["name"]:
+                    basename = os.path.basename(filepath)
+                    if layer_type == "image":
+                        add_kwargs["name"] = f"C{i+1}: {basename}"
+                    elif layer_type == "labels":
+                        add_kwargs["name"] = f"Labels{i+1}: {basename}"
+                    else:
+                        add_kwargs["name"] = (
+                            f"{layer_type.title()}{i+1}: {basename}"
+                        )
+
+                # Set appropriate blending for multi-channel images
+                if layer_type == "image" and len(layer_data_list) > 1:
+                    add_kwargs["blending"] = "additive"
+
+                # Ensure proper colormap assignment for multi-channel
+                if layer_type == "image" and "colormap" not in add_kwargs:
+                    channel_colormaps = [
+                        "red",
+                        "green",
+                        "blue",
+                        "cyan",
+                        "magenta",
+                        "yellow",
+                    ]
+                    add_kwargs["colormap"] = channel_colormaps[
+                        i % len(channel_colormaps)
+                    ]
+
+                enhanced_layers.append((data, add_kwargs, layer_type))
+
+            return enhanced_layers
+        else:
+            if verbose:
+                print(
+                    f"napari-ome-zarr: Reader returned empty layer list for {filepath}"
+                )
+            return None
+
+    except (ImportError, ValueError, TypeError, OSError) as e:
+        if verbose:
+            print(f"napari-ome-zarr: Failed to load {filepath}: {e}")
+            import traceback
+
+            traceback.print_exc()
+        return None
+
+
+def load_zarr_basic(filepath: str) -> Union[np.ndarray, Any]:
+    """
+    Basic zarr loading with dask support as fallback
+    """
+    try:
+        root = zarr.open(filepath, mode="r")
+
+        # Handle zarr groups vs single arrays
+        if hasattr(root, "arrays"):
+            arrays_list = list(root.arrays())
+            if not arrays_list:
+                raise ValueError(f"No arrays found in zarr group: {filepath}")
+
+            # Try to find the main data array
+            # Look for arrays named '0', 'data', or take the first one
+            main_array = None
+            for name, array in arrays_list:
+                if name in ["0", "data"]:
+                    main_array = array
+                    break
+
+            if main_array is None:
+                main_array = arrays_list[0][1]
+
+            zarr_array = main_array
+        else:
+            zarr_array = root
+
+        # Convert to dask array for lazy loading if available
+        if DASK_AVAILABLE:
+            print(f"Loading zarr as dask array with shape: {zarr_array.shape}")
+            return da.from_zarr(zarr_array)
+        else:
+            print(
+                f"Loading zarr as numpy array with shape: {zarr_array.shape}"
+            )
+            return np.array(zarr_array)
+
+    except (ValueError, TypeError, OSError) as e:
+        print(f"Error in basic zarr loading for {filepath}: {e}")
+        raise
+
+
+def is_ome_zarr(filepath: str) -> bool:
+    """
+    Check if a zarr file is OME-Zarr format by looking for OME metadata
+    """
+    try:
+        if not os.path.exists(filepath):
+            return False
+
+        root = zarr.open(filepath, mode="r")
+
+        if hasattr(root, "attrs") and (
+            "ome" in root.attrs
+            or "omero" in root.attrs
+            or "multiscales" in root.attrs
+        ):
+            return True
+
+        # Check for .zattrs file with OME metadata
+        zattrs_path = os.path.join(filepath, ".zattrs")
+        if os.path.exists(zattrs_path):
+            import json
+
+            try:
+                with open(zattrs_path) as f:
+                    attrs = json.load(f)
+                if (
+                    "ome" in attrs
+                    or "omero" in attrs
+                    or "multiscales" in attrs
+                ):
+                    return True
+            except (OSError, json.JSONDecodeError):
+                pass
+
+        return False
+
+    except (ValueError, TypeError, OSError):
+        return False
+
+
+def get_zarr_info(filepath: str) -> dict:
+    """Get detailed information about a zarr dataset"""
+    info = {
+        "is_ome_zarr": False,
+        "is_multiscale": False,
+        "num_arrays": 0,
+        "arrays": [],
+        "shape": None,
+        "dtype": None,
+        "chunks": None,
+        "has_labels": False,
+        "resolution_levels": 0,
+    }
+
+    try:
+        root = zarr.open(filepath, mode="r")
+        info["is_ome_zarr"] = is_ome_zarr(filepath)
+
+        if hasattr(root, "arrays"):
+            arrays_list = list(root.arrays())
+            info["num_arrays"] = len(arrays_list)
+            info["arrays"] = [name for name, _ in arrays_list]
+
+            if (
+                info["is_ome_zarr"]
+                and hasattr(root, "attrs")
+                and "multiscales" in root.attrs
+            ):
+                info["is_multiscale"] = True
+                multiscales = root.attrs["multiscales"]
+                if multiscales and len(multiscales) > 0:
+                    datasets = multiscales[0].get("datasets", [])
+                    info["resolution_levels"] = len(datasets)
+
+            if arrays_list:
+                first_array = arrays_list[0][1]
+                info["shape"] = first_array.shape
+                info["dtype"] = str(first_array.dtype)
+                info["chunks"] = first_array.chunks
+
+            info["has_labels"] = "labels" in info["arrays"]
+
+        else:
+            info["num_arrays"] = 1
+            info["shape"] = root.shape
+            info["dtype"] = str(root.dtype)
+            info["chunks"] = root.chunks
+
+    except (ValueError, TypeError, OSError) as e:
+        print(f"Error getting zarr info for {filepath}: {e}")
+
+    return info
+
+
+def load_image_file(filepath: str) -> Union[np.ndarray, List, Any]:
+    """
+    Load image from file, supporting both TIFF and Zarr formats with proper metadata handling
+    """
+    if filepath.lower().endswith(".zarr"):
+
+        # Try to use napari-ome-zarr reader first for proper metadata handling
+        if OME_ZARR_AVAILABLE:
+            try:
+                layer_data_list = load_zarr_with_napari_ome_zarr(filepath)
+                if layer_data_list:
+                    print(
+                        f"Loaded {len(layer_data_list)} layers from OME-Zarr"
+                    )
+                    return layer_data_list
+            except (ImportError, ValueError, TypeError, OSError) as e:
+                print(
+                    f"napari-ome-zarr reader failed: {e}, falling back to basic zarr loading"
+                )
+
+        # Fallback to basic zarr loading with dask
+        return load_zarr_basic(filepath)
+    else:
+        # Use tifffile for TIFF files to preserve dimension order
+        # (skimage.io.imread may transpose dimensions)
+        if _HAS_TIFFFILE and (
+            filepath.lower().endswith(".tif")
+            or filepath.lower().endswith(".tiff")
+        ):
+            return tifffile.imread(filepath)
+        else:
+            return imread(filepath)
+
 
 class ProcessedFilesTableWidget(QTableWidget):
     """
@@ -65,9 +470,9 @@ class ProcessedFilesTableWidget(QTableWidget):
         # Track file mappings
         self.file_pairs = {}
 
-        # Currently loaded images
-        self.current_original_image = None
-        self.current_processed_image = None
+        # Currently loaded images (can be multiple for multi-channel)
+        self.current_original_images = []
+        self.current_processed_images = []
 
         # For tracking multi-output files
         self.multi_output_files = {}
@@ -108,15 +513,6 @@ class ProcessedFilesTableWidget(QTableWidget):
     def update_processed_files(self, processing_info: List[Dict]):
         """
         Update table with processed files
-
-        Args:
-            processing_info: List of dictionaries containing:
-                {
-                    'original_file': original filepath,
-                    'processed_file': processed filepath (single output)
-                    - OR -
-                    'processed_files': list of processed filepaths (multi-output)
-                }
         """
         for item in processing_info:
             original_file = item["original_file"]
@@ -214,9 +610,57 @@ class ProcessedFilesTableWidget(QTableWidget):
                 if filepath:
                     self._load_processed_image(filepath)
 
+    def _clear_current_images(self, image_list):
+        """Helper to clear a list of current images"""
+        for img_layer in image_list:
+            try:
+                if img_layer in self.viewer.layers:
+                    self.viewer.layers.remove(img_layer)
+                else:
+                    # Try by name if reference doesn't work
+                    layer_names = [layer.name for layer in self.viewer.layers]
+                    if img_layer.name in layer_names:
+                        self.viewer.layers.remove(img_layer.name)
+            except (KeyError, ValueError, AttributeError) as e:
+                print(f"Warning: Could not remove layer: {e}")
+        image_list.clear()
+
+    def _should_enable_3d_view(self, data):
+        """
+        Check if 3D view should be enabled based on data dimensions.
+
+        Conservative approach: Only enable 3D view for clearly spatial 3D data (Z-stacks),
+        not for time series which should use 2D view with time slider.
+        """
+        if not hasattr(data, "shape") or len(data.shape) < 3:
+            return False
+
+        shape = data.shape
+
+        # If first dimension is channels (2-4), check remaining dims
+        if shape[0] >= 2 and shape[0] <= 4:
+            meaningful_dims = shape[1:]
+        else:
+            meaningful_dims = shape
+
+        # Only enable 3D view for data with 4+ dimensions (like TZYX, CZYX)
+        # or 3D data with many slices (likely a Z-stack, not time series)
+        if len(meaningful_dims) >= 4:
+            # TZYX or similar - check Z dimension
+            z_dim = meaningful_dims[1] if len(meaningful_dims) >= 4 else 1
+            return z_dim > 1
+        elif len(meaningful_dims) == 3:
+            # Could be ZYX (spatial) or TYX (temporal)
+            # Only enable 3D for many slices (likely Z-stack)
+            # 10+ slices suggests Z-stack, fewer suggests time series
+            first_dim = meaningful_dims[0]
+            return first_dim > 10
+
+        return False
+
     def _load_original_image(self, filepath: str):
         """
-        Load original image into viewer
+        Load original image into viewer with proper multi-channel support using napari-ome-zarr
         """
         # Ensure filepath is valid
         if not filepath or not os.path.exists(filepath):
@@ -224,60 +668,223 @@ class ProcessedFilesTableWidget(QTableWidget):
             self.viewer.status = f"Error: File not found: {filepath}"
             return
 
-        # Remove existing original layer if it exists
-        if self.current_original_image is not None:
-            try:
-                # Check if the layer is still in the viewer
-                if self.current_original_image in self.viewer.layers:
-                    self.viewer.layers.remove(self.current_original_image)
-                else:
-                    # If not found by reference, try by name
-                    layer_names = [layer.name for layer in self.viewer.layers]
-                    if self.current_original_image.name in layer_names:
-                        self.viewer.layers.remove(
-                            self.current_original_image.name
-                        )
-            except (KeyError, ValueError) as e:
-                print(
-                    f"Warning: Could not remove previous original layer: {e}"
-                )
-
-            # Reset the current original image reference
-            self.current_original_image = None
+        # Remove existing original layers
+        self._clear_current_images(self.current_original_images)
 
         # Load new image
         try:
             # Display status while loading
             self.viewer.status = f"Loading {os.path.basename(filepath)}..."
 
-            image = imread(filepath)
-            # remove singletons
-            image = np.squeeze(image)
-            # check if label image by checking file name
-            is_label = "labels" in os.path.basename(
-                filepath
-            ) or "semantic" in os.path.basename(filepath)
+            # For zarr files, use viewer.open() with the napari-ome-zarr plugin directly
+            if filepath.lower().endswith(".zarr") and OME_ZARR_AVAILABLE:
+                print("Using viewer.open() with napari-ome-zarr plugin")
+
+                # Use napari's built-in open method with the plugin
+                # This is exactly what napari does when you open a zarr file
+                try:
+                    layers = self.viewer.open(
+                        filepath, plugin="napari-ome-zarr"
+                    )
+
+                    # Track the added layers
+                    if layers:
+                        if isinstance(layers, list):
+                            self.current_original_images.extend(layers)
+                        else:
+                            self.current_original_images.append(layers)
+
+                        # Check if we should enable 3D view
+                        if len(self.current_original_images) > 0:
+                            first_layer = self.current_original_images[0]
+                            if hasattr(
+                                first_layer, "data"
+                            ) and self._should_enable_3d_view(
+                                first_layer.data
+                            ):
+                                self.viewer.dims.ndisplay = 3
+                                print(
+                                    f"Switched to 3D view for data with shape: {first_layer.data.shape}"
+                                )
+
+                        self.viewer.status = f"Loaded {len(self.current_original_images)} layers from {os.path.basename(filepath)}"
+                        return
+                    else:
+                        print(
+                            "napari-ome-zarr returned no layers, falling back to manual loading"
+                        )
+                except (ImportError, ValueError, TypeError, OSError) as e:
+                    print(
+                        f"napari-ome-zarr failed: {e}, falling back to manual loading"
+                    )
+
+            # Fallback for non-zarr files or if napari-ome-zarr fails
+            # Load image using the unified loader function
+            image_data = load_image_file(filepath)
+
+            # Handle multi-layer data from OME-Zarr or enhanced basic loading
+            if isinstance(image_data, list):
+                # Channel-specific colormaps: R, G, B, then additional colors
+                channel_colormaps = [
+                    "red",
+                    "green",
+                    "blue",
+                    "cyan",
+                    "magenta",
+                    "yellow",
+                    "orange",
+                    "purple",
+                    "pink",
+                    "gray",
+                ]
+
+                # This is from napari-ome-zarr reader or enhanced basic loading - add each layer separately
+                for layer_idx, layer_info in enumerate(image_data):
+                    # Handle different formats of layer_info
+                    if isinstance(layer_info, tuple) and len(layer_info) == 3:
+                        # Format: (data, add_kwargs, layer_type)
+                        data, add_kwargs, layer_type = layer_info
+                    elif (
+                        isinstance(layer_info, tuple) and len(layer_info) == 2
+                    ):
+                        # Format: (data, add_kwargs) - assume image type
+                        data, add_kwargs = layer_info
+                        layer_type = "image"
+                    else:
+                        # Just data - create minimal kwargs
+                        data = layer_info
+                        add_kwargs = {}
+                        layer_type = "image"
+
+                    base_filename = os.path.basename(filepath)
+
+                    if layer_type == "image":
+                        # Check if this is a multi-channel image that needs to be split using channel_axis
+                        if hasattr(data, "shape") and len(data.shape) >= 3:
+                            # Look for a channel dimension (small dimension, typically <= 10)
+                            potential_channel_dims = []
+                            for dim_idx, dim_size in enumerate(data.shape):
+                                if dim_size <= 10 and dim_size > 1:
+                                    potential_channel_dims.append(
+                                        (dim_idx, dim_size)
+                                    )
+
+                            # If we found a potential channel dimension, use napari's channel_axis
+                            if potential_channel_dims:
+                                # Use the first potential channel dimension
+                                channel_axis, num_channels = (
+                                    potential_channel_dims[0]
+                                )
+                                print(
+                                    f"Using napari channel_axis={channel_axis} for {num_channels} channels"
+                                )
+
+                                # Let napari handle channel splitting automatically with proper colormaps
+                                layers = self.viewer.add_image(
+                                    data,
+                                    channel_axis=channel_axis,
+                                    name=f"Original: {base_filename}",
+                                    blending="additive",
+                                )
+
+                                # Track all the layers napari created
+                                if isinstance(layers, list):
+                                    self.current_original_images.extend(layers)
+                                else:
+                                    self.current_original_images.append(layers)
+
+                                continue  # Skip the normal single-layer processing
+
+                        # Normal single-layer processing (no channel splitting needed)
+                        # Override/set colormap for proper channel assignment
+                        if "colormap" not in add_kwargs:
+                            add_kwargs["colormap"] = (
+                                channel_colormaps[layer_idx]
+                                if layer_idx < len(channel_colormaps)
+                                else "gray"
+                            )
+
+                        if "blending" not in add_kwargs:
+                            add_kwargs["blending"] = (
+                                "additive"  # Enable proper multi-channel blending
+                            )
+
+                        # Ensure proper naming
+                        if "name" not in add_kwargs or not add_kwargs["name"]:
+                            add_kwargs["name"] = (
+                                f"C{layer_idx+1}: {base_filename}"
+                            )
+
+                        layer = self.viewer.add_image(data, **add_kwargs)
+                        self.current_original_images.append(layer)
+
+                    elif layer_type == "labels":
+                        if "name" not in add_kwargs or not add_kwargs["name"]:
+                            add_kwargs["name"] = (
+                                f"Labels{layer_idx+1}: {base_filename}"
+                            )
+
+                        layer = self.viewer.add_labels(data, **add_kwargs)
+                        self.current_original_images.append(layer)
+
+                # Switch to 3D view if data has meaningful 3D dimensions
+                if len(self.current_original_images) > 0:
+                    # Get the first layer's data safely
+                    first_layer = self.current_original_images[0]
+                    if hasattr(first_layer, "data"):
+                        first_layer_data = first_layer.data
+                        if self._should_enable_3d_view(first_layer_data):
+                            self.viewer.dims.ndisplay = 3
+                            print(
+                                f"Switched to 3D view for data with shape: {first_layer_data.shape}"
+                            )
+
+                self.viewer.status = f"Loaded {len(self.current_original_images)} channels from {os.path.basename(filepath)}"
+                return
+
+            # Handle single image data (TIFF or simple zarr)
+            image = image_data
+
+            # Remove singletons if it's a numpy array
+            if hasattr(image, "squeeze") and not hasattr(image, "chunks"):
+                image = np.squeeze(image)
+
+            # Don't automatically split channels - let napari handle with sliders
+            # This avoids confusion between channels (C) and time (T) dimensions
+            # Users can manually split if needed using the "Split Color Channels" function
+            base_filename = os.path.basename(filepath)
+            # check if label image by checking image dtype
+            is_label = is_label_image(image)
+
             if is_label:
-                image = image.astype(np.uint32)
-                self.current_original_image = self.viewer.add_labels(
-                    image, name=f"Labels: {os.path.basename(filepath)}"
+                if hasattr(image, "astype"):
+                    image = image.astype(np.uint32)
+                layer = self.viewer.add_labels(
+                    image, name=f"Labels: {base_filename}"
                 )
             else:
-                self.current_original_image = self.viewer.add_image(
-                    image, name=f"Original: {os.path.basename(filepath)}"
+                layer = self.viewer.add_image(
+                    image, name=f"Original: {base_filename}"
                 )
 
-            # Update status with success message
-            self.viewer.status = f"Loaded {os.path.basename(filepath)}"
+            self.current_original_images.append(layer)
+
+            # Don't automatically switch to 3D view - let user decide
+            # napari will show appropriate sliders for all dimensions
+
+            self.viewer.status = f"Loaded {base_filename}"
 
-        except (ValueError, TypeError, OSError, tifffile.TiffFileError) as e:
+        except (ValueError, TypeError, OSError, ImportError) as e:
             print(f"Error loading original image {filepath}: {e}")
+            import traceback
+
+            traceback.print_exc()
             self.viewer.status = f"Error processing {filepath}: {e}"
 
     def _load_processed_image(self, filepath: str):
         """
-        Load processed image into viewer, distinguishing labels by filename pattern
-        and ensure it's always shown on top
+        Load processed image into viewer with multi-channel support and ensure it's always shown on top
+        Also handles points data from spot detection functions.
         """
         # Ensure filepath is valid
         if not filepath or not os.path.exists(filepath):
@@ -285,70 +892,320 @@ class ProcessedFilesTableWidget(QTableWidget):
             self.viewer.status = f"Error: File not found: {filepath}"
             return
 
-        # Remove existing processed layer if it exists
-        if self.current_processed_image is not None:
+        # Remove existing processed layers
+        self._clear_current_images(self.current_processed_images)
+
+        # Special handling for .npy files (likely points data from spot detection)
+        if filepath.lower().endswith(".npy"):
             try:
-                # Check if the layer is still in the viewer
-                if self.current_processed_image in self.viewer.layers:
-                    self.viewer.layers.remove(self.current_processed_image)
+                data = np.load(filepath)
+
+                # Check if this is points data
+                if (
+                    isinstance(data, np.ndarray)
+                    and data.ndim == 2
+                    and data.shape[1] in [2, 3]  # 2D or 3D coordinates
+                    and data.dtype in [np.float32, np.float64]
+                ):  # Coordinate data
+
+                    print(f"Loading points data: {data.shape} points")
+
+                    # Determine if 2D or 3D points
+                    is_3d = data.shape[1] == 3
+
+                    # Set appropriate point properties
+                    point_properties = {
+                        "size": 8,
+                        "symbol": "ring",
+                        "opacity": 1,
+                        "face_color": [1.0, 0.5, 0.2],
+                        "border_color": [1.0, 0.5, 0.2],
+                    }
+
+                    if is_3d:
+                        point_properties["out_of_slice_display"] = True
+
+                    # Add points layer
+                    points_layer = self.viewer.add_points(
+                        data,
+                        name=f"Spots ({os.path.basename(filepath)})",
+                        **point_properties,
+                    )
+
+                    # Track the layer
+                    self.current_processed_images = [points_layer]
+
+                    self.viewer.status = f"Loaded {len(data)} spots from {os.path.basename(filepath)}"
+                    print(
+                        f"Successfully loaded {len(data)} spots as points layer"
+                    )
+                    return
+
                 else:
-                    # If not found by reference, try by name
-                    layer_names = [layer.name for layer in self.viewer.layers]
-                    if self.current_processed_image.name in layer_names:
-                        self.viewer.layers.remove(
-                            self.current_processed_image.name
-                        )
-            except (KeyError, ValueError) as e:
-                print(
-                    f"Warning: Could not remove previous processed layer: {e}"
-                )
+                    print(
+                        "NPY file doesn't contain points data, treating as image"
+                    )
+                    # Fall through to regular image loading
 
-            # Reset the current processed image reference
-            self.current_processed_image = None
+            except (OSError, ValueError, AttributeError) as e:
+                print(f"Error loading NPY file as points: {e}")
+                # Fall through to regular image loading
 
-        # Load new image
+        # Load new image (original logic)
         try:
             # Display status while loading
             self.viewer.status = f"Loading {os.path.basename(filepath)}..."
 
-            image = imread(filepath)
-            # remove singletons
-            image = np.squeeze(image)
-            filename = os.path.basename(filepath)
+            # For zarr files, use viewer.open() with the napari-ome-zarr plugin directly
+            if filepath.lower().endswith(".zarr") and OME_ZARR_AVAILABLE:
+                print(
+                    "Using viewer.open() with napari-ome-zarr plugin for processed image"
+                )
+
+                # Use napari's built-in open method with the plugin
+                try:
+                    layers = self.viewer.open(
+                        filepath, plugin="napari-ome-zarr"
+                    )
+
+                    # Track the added layers and rename them as processed
+                    if layers:
+                        if isinstance(layers, list):
+                            for layer in layers:
+                                layer.name = f"Processed {layer.name}"
+                                self.current_processed_images.append(layer)
+                        else:
+                            layers.name = f"Processed {layers.name}"
+                            self.current_processed_images.append(layers)
+
+                        # Switch to 3D view if data has meaningful 3D dimensions
+                        if len(self.current_processed_images) > 0:
+                            first_layer = self.current_processed_images[0]
+                            if hasattr(first_layer, "data"):
+                                first_layer_data = first_layer.data
+                                if self._should_enable_3d_view(
+                                    first_layer_data
+                                ):
+                                    self.viewer.dims.ndisplay = 3
+                                    print(
+                                        f"Switched to 3D view for processed data with shape: {first_layer_data.shape}"
+                                    )
+
+                        # Move all processed layers to top
+                        for layer in self.current_processed_images:
+                            if layer in self.viewer.layers:
+                                layer_index = self.viewer.layers.index(layer)
+                                if layer_index < len(self.viewer.layers) - 1:
+                                    self.viewer.layers.move(
+                                        layer_index,
+                                        len(self.viewer.layers) - 1,
+                                    )
+
+                        self.viewer.status = f"Loaded {len(self.current_processed_images)} processed layers from {os.path.basename(filepath)}"
+                        return
+                    else:
+                        print(
+                            "napari-ome-zarr returned no layers for processed image, falling back"
+                        )
+                except (ImportError, ValueError, TypeError, OSError) as e:
+                    print(
+                        f"napari-ome-zarr failed for processed image: {e}, falling back"
+                    )
 
-            # Check if filename contains label indicators
-            is_label = "labels" in filename or "semantic" in filename
+            # Fallback for non-zarr files or if napari-ome-zarr fails
+            # Load image using the unified loader function
+            image_data = load_image_file(filepath)
+
+            # Handle multi-layer data from OME-Zarr or enhanced basic loading
+            if isinstance(image_data, list):
+                # Channel-specific colormaps: R, G, B, then additional colors
+                channel_colormaps = [
+                    "red",
+                    "green",
+                    "blue",
+                    "cyan",
+                    "magenta",
+                    "yellow",
+                    "orange",
+                    "purple",
+                    "pink",
+                    "gray",
+                ]
+
+                # This is from napari-ome-zarr reader or enhanced basic loading - add each layer separately
+                for layer_idx, layer_info in enumerate(image_data):
+                    # Handle different formats of layer_info
+                    if isinstance(layer_info, tuple) and len(layer_info) == 3:
+                        # Format: (data, add_kwargs, layer_type)
+                        data, add_kwargs, layer_type = layer_info
+                    elif (
+                        isinstance(layer_info, tuple) and len(layer_info) == 2
+                    ):
+                        # Format: (data, add_kwargs) - assume image type
+                        data, add_kwargs = layer_info
+                        layer_type = "image"
+                    else:
+                        # Just data - create minimal kwargs
+                        data = layer_info
+                        add_kwargs = {}
+                        layer_type = "image"
+
+                    # Ensure proper naming and colormaps for processed images
+                    filename = os.path.basename(filepath)
+
+                    if layer_type == "image":
+                        # Check if this is a multi-channel image that needs to be split using channel_axis
+                        if hasattr(data, "shape") and len(data.shape) >= 3:
+                            # Look for a channel dimension (small dimension, typically <= 10)
+                            potential_channel_dims = []
+                            for dim_idx, dim_size in enumerate(data.shape):
+                                if dim_size <= 10 and dim_size > 1:
+                                    potential_channel_dims.append(
+                                        (dim_idx, dim_size)
+                                    )
+
+                            # If we found a potential channel dimension, use napari's channel_axis
+                            if potential_channel_dims:
+                                # Use the first potential channel dimension
+                                channel_axis, num_channels = (
+                                    potential_channel_dims[0]
+                                )
+                                print(
+                                    f"Using napari channel_axis={channel_axis} for {num_channels} processed channels"
+                                )
+
+                                # Let napari handle channel splitting automatically with proper colormaps
+                                layers = self.viewer.add_image(
+                                    data,
+                                    channel_axis=channel_axis,
+                                    name=f"Processed: {filename}",
+                                    blending="additive",
+                                )
+
+                                # Track all the layers napari created
+                                if isinstance(layers, list):
+                                    self.current_processed_images.extend(
+                                        layers
+                                    )
+                                else:
+                                    self.current_processed_images.append(
+                                        layers
+                                    )
+
+                                continue  # Skip the normal single-layer processing
+
+                        # Normal single-layer processing (no channel splitting needed)
+                        # Override/set colormap for proper channel assignment
+                        if "colormap" not in add_kwargs:
+                            add_kwargs["colormap"] = (
+                                channel_colormaps[layer_idx]
+                                if layer_idx < len(channel_colormaps)
+                                else "gray"
+                            )
+
+                        if "blending" not in add_kwargs:
+                            add_kwargs["blending"] = "additive"
+
+                        # Ensure proper naming for processed images
+                        if "name" not in add_kwargs or not add_kwargs["name"]:
+                            add_kwargs["name"] = (
+                                f"Processed C{layer_idx+1}: {filename}"
+                            )
+                        elif not add_kwargs["name"].startswith("Processed"):
+                            add_kwargs["name"] = (
+                                f"Processed {add_kwargs['name']}"
+                            )
+
+                        layer = self.viewer.add_image(data, **add_kwargs)
+                        self.current_processed_images.append(layer)
+
+                    elif layer_type == "labels":
+                        if "name" not in add_kwargs or not add_kwargs["name"]:
+                            add_kwargs["name"] = (
+                                f"Processed Labels{layer_idx+1}: {filename}"
+                            )
+                        elif not add_kwargs["name"].startswith("Processed"):
+                            add_kwargs["name"] = (
+                                f"Processed {add_kwargs['name']}"
+                            )
+
+                        layer = self.viewer.add_labels(data, **add_kwargs)
+                        self.current_processed_images.append(layer)
+
+                # Switch to 3D view if data has meaningful 3D dimensions
+                if len(self.current_processed_images) > 0:
+                    # Get the first layer's data safely
+                    first_layer = self.current_processed_images[0]
+                    if hasattr(first_layer, "data"):
+                        first_layer_data = first_layer.data
+                        if self._should_enable_3d_view(first_layer_data):
+                            self.viewer.dims.ndisplay = 3
+                            print(
+                                f"Switched to 3D view for processed data with shape: {first_layer_data.shape}"
+                            )
+
+                # Move all processed layers to top
+                for layer in self.current_processed_images:
+                    if layer in self.viewer.layers:
+                        layer_index = self.viewer.layers.index(layer)
+                        if layer_index < len(self.viewer.layers) - 1:
+                            self.viewer.layers.move(
+                                layer_index, len(self.viewer.layers) - 1
+                            )
+
+                self.viewer.status = f"Loaded {len(self.current_processed_images)} processed channels from {os.path.basename(filepath)}"
+                return
+
+            # Handle single image data
+            image = image_data
+
+            # Remove singletons if it's a numpy array
+            if hasattr(image, "squeeze") and not hasattr(image, "chunks"):
+                image = np.squeeze(image)
+
+            # Don't automatically split channels - let napari handle with sliders
+            # This avoids confusion between channels (C) and time (T) dimensions
+            filename = os.path.basename(filepath)
+            # Check if image dtype indicates labels
+            is_label = is_label_image(image)
 
             # Add the layer using the appropriate method
             if is_label:
                 # Ensure it's an appropriate dtype for labels
-                if not np.issubdtype(image.dtype, np.integer):
+                if hasattr(image, "astype") and not np.issubdtype(
+                    image.dtype, np.integer
+                ):
                     image = image.astype(np.uint32)
 
-                self.current_processed_image = self.viewer.add_labels(
-                    image, name=f"Labels: {filename}"
+                layer = self.viewer.add_labels(
+                    image, name=f"Processed Labels: {filename}"
                 )
             else:
-                self.current_processed_image = self.viewer.add_image(
+                layer = self.viewer.add_image(
                     image, name=f"Processed: {filename}"
                 )
 
+            self.current_processed_images.append(layer)
+
+            # Don't automatically switch to 3D view - let user decide
+            # napari will show appropriate sliders for all dimensions
+
             # Move the processed layer to the top of the stack
-            # Get the index of the current processed layer
-            layer_index = self.viewer.layers.index(
-                self.current_processed_image
-            )
-            # Move it to the top (last position in the list)
-            if layer_index < len(self.viewer.layers) - 1:
-                self.viewer.layers.move(
-                    layer_index, len(self.viewer.layers) - 1
-                )
+            if layer in self.viewer.layers:
+                layer_index = self.viewer.layers.index(layer)
+                if layer_index < len(self.viewer.layers) - 1:
+                    self.viewer.layers.move(
+                        layer_index, len(self.viewer.layers) - 1
+                    )
 
             # Update status with success message
             self.viewer.status = f"Loaded {filename} (moved to top layer)"
 
-        except (ValueError, TypeError, OSError, tifffile.TiffFileError) as e:
+        except (ValueError, TypeError, OSError, ImportError) as e:
             print(f"Error loading processed image {filepath}: {e}")
+            import traceback
+
+            traceback.print_exc()
             self.viewer.status = f"Error processing {filepath}: {e}"
 
     def _load_image(self, filepath: str):
@@ -398,6 +1255,11 @@ class ParameterWidget(QWidget):
                 widget.setDecimals(3)
                 if default_value is not None:
                     widget.setValue(default_value)
+            elif param_type is bool:
+                # Use checkbox for boolean parameters
+                widget = QCheckBox()
+                if default_value is not None:
+                    widget.setChecked(bool(default_value))
             else:
                 # Default to text input for other types
                 widget = QLineEdit(
@@ -418,6 +1280,8 @@ class ParameterWidget(QWidget):
 
             if isinstance(widget, (QSpinBox, QDoubleSpinBox)):
                 values[param_name] = widget.value()
+            elif isinstance(widget, QCheckBox):
+                values[param_name] = widget.isChecked()
             else:
                 # For text inputs, try to convert to the appropriate type
                 try:
@@ -436,10 +1300,13 @@ class ParameterWidget(QWidget):
         "label": "Select Folder",
         "value": "",
     },
-    input_suffix={"label": "File Suffix (Example: .tif)", "value": ""},
+    input_suffix={
+        "label": "File Suffix (Example: .tif,.zarr)",
+        "value": ".tif,.zarr",
+    },
 )
 def file_selector(
-    viewer: napari.Viewer, input_folder: str, input_suffix: str = ".tif"
+    viewer: napari.Viewer, input_folder: str, input_suffix: str = ".tif,.zarr"
 ) -> List[str]:
     """
     Find files in a specified input folder with a given suffix and prepare for batch processing.
@@ -449,12 +1316,16 @@ def file_selector(
         viewer.status = f"Invalid input folder: {input_folder}"
         return []
 
-    # Find matching files
-    matching_files = [
-        os.path.join(input_folder, f)
-        for f in os.listdir(input_folder)
-        if f.endswith(input_suffix)
-    ]
+    # Parse multiple suffixes
+    suffixes = [s.strip() for s in input_suffix.split(",") if s.strip()]
+    if not suffixes:
+        suffixes = [".tif"]  # Fallback to tif if no valid suffixes
+
+    # Find matching files with multiple suffix support
+    matching_files = []
+    for f in os.listdir(input_folder):
+        if any(f.endswith(suffix) for suffix in suffixes):
+            matching_files.append(os.path.join(input_folder, f))
 
     # Create a results widget with batch processing option
     results_widget = FileResultsWidget(
@@ -475,56 +1346,11 @@ def file_selector(
     return matching_files
 
 
-# Modify the file_selector widget to add a browse button after it's created
-def _add_browse_button_to_selector(file_selector_widget):
-    """
-    Add a browse button to the file selector widget
-    """
-    # Get the container widget that holds the input_folder widget
-    container = file_selector_widget.native
-
-    # Create a browse button
-    browse_button = QPushButton("Browse...")
-
-    # Get access to the input_folder widget
-    input_folder_widget = file_selector_widget.input_folder.native
-
-    # Get the parent of the input_folder widget
-    parent_layout = input_folder_widget.parentWidget().layout()
-
-    # Create a container for input field and browse button
-    container_widget = QWidget()
-    h_layout = QHBoxLayout(container_widget)
-    h_layout.setContentsMargins(0, 0, 0, 0)
-
-    # Add the input field to our container
-    h_layout.addWidget(input_folder_widget)
-
-    # Add the browse button
-    h_layout.addWidget(browse_button)
-
-    # Replace the input field with our container
-    layout_index = parent_layout.indexOf(input_folder_widget)
-    parent_layout.removeWidget(input_folder_widget)
-    parent_layout.insertWidget(layout_index, container_widget)
-
-    # Connect button to browse action
-    def browse_folder():
-        folder = QFileDialog.getExistingDirectory(
-            container,
-            "Select Folder",
-            file_selector_widget.input_folder.value or os.path.expanduser("~"),
-        )
-        if folder:
-            file_selector_widget.input_folder.value = folder
-
-    browse_button.clicked.connect(browse_folder)
-
-    return file_selector_widget
-
-
 # Create a modified file_selector with browse button
-file_selector = _add_browse_button_to_selector(file_selector)
+if _HAS_MAGICGUI and _HAS_QTPY:
+    file_selector = add_browse_button_to_folder_field(
+        file_selector, "input_folder"
+    )
 
 
 # Processing worker for multithreading
@@ -608,13 +1434,54 @@ class ProcessingWorker(QThread):
         self.processing_finished.emit()
 
     def process_file(self, filepath):
-        """Process a single file with support for large TIFF files and removal of all singleton dimensions"""
+        """Process a single file with support for large TIFF and Zarr files"""
         try:
-            # Load the image
-            image = imread(filepath)
-            image_dtype = image.dtype
+            # Load the image using the unified loader
+            image_data = load_image_file(filepath)
 
-            print(f"Original image shape: {image.shape}, dtype: {image_dtype}")
+            # Handle multi-layer data from OME-Zarr - extract first layer for processing
+            if isinstance(image_data, list):
+                print(
+                    f"Processing first layer of multi-layer file: {filepath}"
+                )
+                # Take the first image layer
+                for data, add_kwargs, layer_type in image_data:
+                    if layer_type == "image":
+                        image = data
+                        # Extract metadata if available
+                        if isinstance(add_kwargs, dict):
+                            metadata = add_kwargs.get("metadata", {})
+                            if "axes" in metadata:
+                                print(f"Zarr axes: {metadata['axes']}")
+                            if "channel_axis" in metadata:
+                                print(
+                                    f"Channel axis: {metadata['channel_axis']}"
+                                )
+                        break
+                else:
+                    # No image layer found, take first available
+                    image = image_data[0][0]
+            else:
+                image = image_data
+
+            # Store original dtype for saving
+            if hasattr(image, "dtype"):
+                image_dtype = image.dtype
+            else:
+                image_dtype = np.float32
+
+            # Get shape information for different array types
+            if hasattr(image, "shape"):
+                shape_info = f"{image.shape}"
+            elif hasattr(image, "__array__"):
+                # For array-like objects
+                try:
+                    arr = np.asarray(image)
+                    shape_info = f"{arr.shape} (converted from array-like)"
+                except (ValueError, TypeError, AttributeError):
+                    shape_info = "unknown (array conversion failed)"
+            else:
+                shape_info = "unknown (no shape attribute)"
 
             # Check if this is a folder-processing function that shouldn't save individual files
             function_name = getattr(
@@ -624,30 +1491,261 @@ class ProcessingWorker(QThread):
                 "timepoint" in function_name.lower()
                 or "merge" in function_name.lower()
                 or "folder" in function_name.lower()
+                or "grid" in function_name.lower()
             )
 
+            # Convert dask array to numpy for processing functions that don't support dask
+            if hasattr(image, "chunks") and hasattr(image, "compute"):
+                print("Converting dask array to numpy for processing...")
+                # For very large arrays, we might want to process in chunks
+                try:
+                    image = image.compute()
+                except MemoryError:
+                    print(
+                        "Memory error computing dask array, trying chunked processing..."
+                    )
+                    # Could implement chunked processing here if needed
+                    raise
+
             # Apply processing with parameters
-            processed_image = self.processing_func(image, **self.param_values)
+            # For zarr files, pass the original filepath to enable optimized processing
+            if filepath.lower().endswith(".zarr"):
+                # Add filepath for zarr-aware processing functions
+                processing_params = {
+                    **self.param_values,
+                    "_source_filepath": filepath,
+                }
+            else:
+                processing_params = self.param_values
+
+            processed_result = self.processing_func(image, **processing_params)
+
+            if processed_result is None:
+                # Allow processing functions to signal that this file should be skipped
+                # Suppress message for grid_overlay since it's expected to return None for most files
+                if not is_folder_function:
+                    print(
+                        "Processing function returned None; skipping save for this file."
+                    )
+                return None
+
+            # Check if result is points data (for spot detection functions)
+            if (
+                isinstance(processed_result, np.ndarray)
+                and processed_result.ndim == 2
+                and processed_result.shape[1] in [2, 3]  # 2D or 3D coordinates
+                and processed_result.dtype in [np.float32, np.float64]
+            ):  # Coordinate data
+
+                print(f"Detected points data: {processed_result.shape} points")
+
+                # Save points as numpy array
+                filename = os.path.basename(filepath)
+                name, _ = os.path.splitext(filename)
+                points_filename = f"{name}_spots.npy"
+                points_filepath = os.path.join(
+                    self.output_folder, points_filename
+                )
+
+                np.save(points_filepath, processed_result)
+                print(f"Saved points to: {points_filepath}")
+
+                # Also save as CSV if requested
+                if hasattr(self, "param_values") and self.param_values.get(
+                    "output_csv", False
+                ):
+                    csv_filename = f"{name}_spots.csv"
+                    csv_filepath = os.path.join(
+                        self.output_folder, csv_filename
+                    )
+
+                    try:
+                        # Try to save as CSV with pandas
+                        import pandas as pd
+
+                        columns = (
+                            ["y", "x"]
+                            if processed_result.shape[1] == 2
+                            else ["z", "y", "x"]
+                        )
+                        df = pd.DataFrame(processed_result, columns=columns)
+                        df.to_csv(csv_filepath, index=False)
+                        print(f"Saved CSV to: {csv_filepath}")
+                    except ImportError:
+                        # Fallback to numpy if pandas not available
+                        np.savetxt(
+                            csv_filepath,
+                            processed_result,
+                            delimiter=",",
+                            header=(
+                                "y,x"
+                                if processed_result.shape[1] == 2
+                                else "z,y,x"
+                            ),
+                            comments="",
+                        )
+                        print(f"Saved CSV (numpy fallback) to: {csv_filepath}")
+
+                return {
+                    "original_file": filepath,
+                    "processed_file": points_filepath,
+                }
+
+            # Handle functions that return multiple outputs (e.g., channel splitting, layer subdivision)
+            if (
+                isinstance(processed_result, (list, tuple))
+                and len(processed_result) > 1
+            ):
+                # Multiple outputs - save each as separate file
+                processed_files = []
+                base_name = os.path.splitext(os.path.basename(filepath))[0]
+
+                # Check if this is a layer subdivision function (returns 3 outputs)
+                if (
+                    len(processed_result) == 3
+                    and self.output_suffix == "_layer"
+                ):
+                    layer_names = [
+                        "_inner",
+                        "_middle",
+                        "_outer",
+                    ]
+                    for idx, (img, layer_name) in enumerate(
+                        zip(processed_result, layer_names)
+                    ):
+                        if not isinstance(img, np.ndarray):
+                            continue
+
+                        # Remove singleton dimensions
+                        img = np.squeeze(img)
+
+                        # Generate output filename with layer name
+                        output_filename = f"{base_name}{layer_name}.tif"
+                        output_path = os.path.join(
+                            self.output_folder, output_filename
+                        )
+
+                        print(
+                            f"Layer {idx + 1} ({layer_name}) shape: {img.shape}"
+                        )
+
+                        # Calculate approx file size in GB
+                        size_gb = img.size * img.itemsize / (1024**3)
+                        print(f"Estimated file size: {size_gb:.2f} GB")
+
+                        # Check data range
+                        data_min = np.min(img) if img.size > 0 else 0
+                        data_max = np.max(img) if img.size > 0 else 0
+                        print(
+                            f"Layer {idx + 1} data range: {data_min} to {data_max}"
+                        )
+
+                        # For very large files, use BigTIFF format
+                        use_bigtiff = size_gb > 2.0
+
+                        # Layer subdivision outputs should always be saved as uint32
+                        # to ensure Napari auto-detects them as labels
+                        save_dtype = np.uint32
+
+                        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:
+                    # Default behavior for other multi-output functions (e.g., channel splitting)
+                    for idx, img in enumerate(processed_result):
+                        if not isinstance(img, np.ndarray):
+                            continue
+
+                        # Remove singleton dimensions
+                        img = np.squeeze(img)
+
+                        # Generate output filename
+                        output_filename = (
+                            f"{base_name}_ch{idx + 1}{self.output_suffix}"
+                        )
+                        output_path = os.path.join(
+                            self.output_folder, output_filename
+                        )
+
+                        print(f"Output {idx + 1} shape: {img.shape}")
+
+                        # Calculate approx file size in GB
+                        size_gb = img.size * img.itemsize / (1024**3)
+                        print(f"Estimated file size: {size_gb:.2f} GB")
+
+                        # Check data range
+                        data_min = np.min(img) if img.size > 0 else 0
+                        data_max = np.max(img) if img.size > 0 else 0
+                        print(
+                            f"Output {idx + 1} data range: {data_min} to {data_max}"
+                        )
+
+                        # For very large files, use BigTIFF format
+                        use_bigtiff = size_gb > 2.0
+
+                        # Check if this is a label image based on dtype
+                        is_label = is_label_image(img)
+
+                        if is_label:
+                            # 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}"
+                            )
+                            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,
+                            )
+
+                        processed_files.append(output_path)
+
+                return {
+                    "original_file": filepath,
+                    "processed_files": processed_files,
+                }
+
+            # Handle as image data (original logic)
+            processed_image = processed_result
 
             print(
                 f"Processed image shape before removing singletons: {processed_image.shape}, dtype: {processed_image.dtype}"
             )
 
-            # For folder functions, check if the output is the same as input (indicating no individual file should be saved)
+            # For folder functions, check if the output is the same as input
             if is_folder_function:
-                # If the function returns the original image unchanged, it means it handled saving internally
                 if np.array_equal(processed_image, image):
                     print(
                         "Folder function returned unchanged image - skipping individual file save"
                     )
-                    return None  # Return None to indicate no file should be created
+                    return None
                 else:
                     print(
                         "Folder function returned different data - will save individual file"
                     )
 
             # Remove ALL singleton dimensions from the processed image
-            # This will keep only dimensions with size > 1
             processed_image = np.squeeze(processed_image)
 
             print(
@@ -657,27 +1755,75 @@ class ProcessingWorker(QThread):
             # Generate new filename base
             filename = os.path.basename(filepath)
             name, ext = os.path.splitext(filename)
-            if name.endswith(self.input_suffix):
+
+            # Handle multiple input suffixes for filename generation
+            input_suffixes = [
+                s.strip() for s in self.input_suffix.split(",") if s.strip()
+            ]
+            matched_suffix = ""
+            for suffix in input_suffixes:
+                suffix_clean = suffix.replace(
+                    ".", ""
+                )  # Remove dot for comparison
+                if name.endswith(suffix_clean):
+                    matched_suffix = suffix_clean
+                    break
+
+            if matched_suffix:
                 new_filename_base = (
-                    name[: -len(self.input_suffix)] + self.output_suffix
+                    name[: -len(matched_suffix)] + self.output_suffix
                 )
             else:
                 new_filename_base = name + self.output_suffix
 
+            # For zarr input, default to .tif output unless processing function specifies otherwise
+            if filepath.lower().endswith(".zarr") and ext == ".zarr":
+                ext = ".tif"
+
             # Check if the first dimension should be treated as channels
-            # If processed_image has more dimensions than the original image,
-            # assume the first dimension represents channels
-            is_multi_channel = (processed_image.ndim > image.ndim - 1) or (
-                processed_image.ndim == image.ndim
-                and processed_image.shape[0] <= 10
+            # Respect dimension_order hint if provided, otherwise use heuristic (2-4 channels for RGB/RGBA)
+            dimension_order_hint = processing_params.get(
+                "dimension_order", "Auto"
             )
 
-            if (
-                is_multi_channel and processed_image.shape[0] <= 10
-            ):  # Reasonable number of channels
+            # Only split if dimension_order indicates channels (CYX, TCYX, etc. with C first)
+            # or if Auto and shape suggests channels (2-4)
+            is_multi_channel = False
+            if dimension_order_hint in [
+                "CYX",
+                "CZYX",
+                "TCYX",
+                "ZCYX",
+                "TZCYX",
+            ]:
+                # User explicitly said first dim is channels - split it
+                is_multi_channel = (
+                    processed_image.ndim > 2 and processed_image.shape[0] > 1
+                )
+                print(
+                    f"dimension_order='{dimension_order_hint}' indicates channels, will split {processed_image.shape[0]} channels"
+                )
+            elif dimension_order_hint in ["TYX", "ZYX", "TZYX"]:
+                # User explicitly said it's NOT channels (time or Z) - don't split
+                is_multi_channel = False
+                print(
+                    f"dimension_order='{dimension_order_hint}' indicates time/Z dimension, will NOT split channels"
+                )
+            elif dimension_order_hint == "Auto":
+                # Auto mode: use old heuristic (2-4 suggests channels)
+                is_multi_channel = (
+                    processed_image.ndim > 2
+                    and processed_image.shape[0] <= 4
+                    and processed_image.shape[0] > 1
+                )
+                if is_multi_channel:
+                    print(
+                        f"Auto mode: shape[0]={processed_image.shape[0]} <= 4, assuming channels"
+                    )
+
+            if is_multi_channel:
                 # Save each channel as a separate image
                 processed_files = []
-
                 num_channels = processed_image.shape[0]
                 print(
                     f"Treating first dimension as channels. Saving {num_channels} separate channel files"
@@ -709,22 +1855,16 @@ class ProcessingWorker(QThread):
                     )
                     print(f"Channel {i} data range: {data_min} to {data_max}")
 
-                    # For very large files, we need to use BigTIFF format
-                    use_bigtiff = (
-                        size_gb > 2.0
-                    )  # Use BigTIFF for files over 2GB
+                    # For very large files, use BigTIFF format
+                    use_bigtiff = size_gb > 2.0
 
-                    if (
-                        "labels" in channel_filename
-                        or "semantic" in channel_filename
-                    ):
-                        # 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
+                    # Check if this is a label image based on dtype
+                    is_label = is_label_image(channel_image)
+
+                    if is_label:
+                        # 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}"
@@ -736,12 +1876,9 @@ class ProcessingWorker(QThread):
                             bigtiff=use_bigtiff,
                         )
                     else:
-                        # Handle large images with bigtiff format
                         print(
                             f"Regular image channel, saving with dtype {image_dtype} and bigtiff={use_bigtiff}"
                         )
-
-                        # Save with original dtype and bigtiff format if needed
                         tifffile.imwrite(
                             channel_filepath,
                             channel_image.astype(image_dtype),
@@ -751,7 +1888,6 @@ class ProcessingWorker(QThread):
 
                     processed_files.append(channel_filepath)
 
-                # Return processing info
                 return {
                     "original_file": filepath,
                     "processed_files": processed_files,
@@ -770,8 +1906,8 @@ class ProcessingWorker(QThread):
                 )
                 print(f"Estimated file size: {size_gb:.2f} GB")
 
-                # For very large files, we need to use BigTIFF format
-                use_bigtiff = size_gb > 2.0  # Use BigTIFF for files over 2GB
+                # For very large files, use BigTIFF format
+                use_bigtiff = size_gb > 2.0
 
                 # Check data range
                 data_min = (
@@ -782,13 +1918,11 @@ class ProcessingWorker(QThread):
                 )
                 print(f"Data range: {data_min} to {data_max}")
 
-                if (
-                    "labels" in new_filename_base
-                    or "semantic" in 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
-
                     print(
                         f"Saving label image as {save_dtype.__name__} with bigtiff={use_bigtiff}"
                     )
@@ -809,7 +1943,6 @@ class ProcessingWorker(QThread):
                         bigtiff=use_bigtiff,
                     )
 
-                # Return processing info
                 return {
                     "original_file": filepath,
                     "processed_file": new_filepath,
@@ -872,6 +2005,44 @@ class FileResultsWidget(QWidget):
 
         # Create processing function selector
         processing_layout = QVBoxLayout()
+
+        # Add dimension order selector FIRST (before function selector)
+        dim_order_layout = QHBoxLayout()
+        dim_order_label = QLabel("Dimension Order (optional hint):")
+        dim_order_label.setToolTip(
+            "Help processing functions interpret multi-dimensional data.\n"
+            "• Auto: Let function decide (default)\n"
+            "• YX: 2D image\n"
+            "• CYX: Channels first (e.g., RGB)\n"
+            "• TYX: Time series\n"
+            "• ZYX: Z-stack\n"
+            "• TCYX, TZYX, etc.: Combined dimensions\n"
+            "\nNote: Not all functions use this hint."
+        )
+        dim_order_layout.addWidget(dim_order_label)
+
+        self.dimension_order = QComboBox()
+        self.dimension_order.addItems(
+            [
+                "Auto",
+                "YX",
+                "CYX",
+                "TYX",
+                "ZYX",
+                "TCYX",
+                "TZYX",
+                "ZCYX",
+                "TZCYX",
+            ]
+        )
+        self.dimension_order.setToolTip(
+            "Dimension interpretation hint for processing functions"
+        )
+        dim_order_layout.addWidget(self.dimension_order)
+        dim_order_layout.addStretch()
+        processing_layout.addLayout(dim_order_layout)
+
+        # Now add processing function selector
         processing_label = QLabel("Select Processing Function:")
         processing_layout.addWidget(processing_label)
 
@@ -971,6 +2142,7 @@ class FileResultsWidget(QWidget):
             "folder" in function_name.lower()
             or "timepoint" in function_name.lower()
             or "merge" in function_name.lower()
+            or "grid" in function_name.lower()
             or "folder" in description.lower()
             or "cellpose" in description.lower()
             or "careamics" in description.lower()
@@ -1053,6 +2225,17 @@ class FileResultsWidget(QWidget):
         processing_func = function_info["func"]
         output_suffix = function_info["suffix"]
 
+        # Ensure grid overlay cache is reset before each new run
+        if getattr(processing_func, "__name__", "") == "create_grid_overlay":
+            try:
+                from napari_tmidas.processing_functions.grid_view_overlay import (
+                    reset_grid_cache,
+                )
+
+                reset_grid_cache()
+            except ImportError:
+                pass
+
         # Get parameter values if available
         param_values = {}
         if hasattr(self, "param_widget_instance") and hasattr(
@@ -1060,6 +2243,12 @@ class FileResultsWidget(QWidget):
         ):
             param_values = self.param_widget_instance.get_parameter_values()
 
+        # Add dimension order hint if not "Auto"
+        if hasattr(self, "dimension_order"):
+            dim_order = self.dimension_order.currentText()
+            if dim_order != "Auto":
+                param_values["dimension_order"] = dim_order
+
         # Determine output folder
         output_folder = self.output_folder.text().strip()
         if not output_folder:
@@ -1147,6 +2336,52 @@ class FileResultsWidget(QWidget):
             f"Completed processing {len(self.processed_files_info)} files"
         )
 
+        # For grid overlay function, load and display the result
+        if hasattr(self, "processing_selector"):
+            function_name = self.processing_selector.currentText()
+            if "grid" in function_name.lower():
+                # Import here to avoid circular dependency
+                try:
+                    from napari_tmidas.processing_functions.grid_view_overlay import (
+                        _grid_output_path,
+                    )
+
+                    if _grid_output_path:
+                        import tifffile
+
+                        # Load TIF image
+                        grid_image = tifffile.imread(_grid_output_path)
+
+                        # Add to viewer
+                        self.viewer.add_image(
+                            grid_image,
+                            name=f"Grid Overlay ({len(self.file_list)} pairs)",
+                            rgb=True,
+                        )
+                        print("\n✨ Grid overlay added to napari viewer!")
+
+                        # Show message box with output location
+                        msg = QMessageBox(self)
+                        msg.setIcon(QMessageBox.Information)
+                        msg.setWindowTitle("Grid Overlay Complete")
+                        msg.setText(
+                            f"Grid overlay created successfully!\n\nProcessed {len(self.file_list)} image pairs"
+                        )
+                        msg.setInformativeText(
+                            f"Saved to:\n{_grid_output_path}"
+                        )
+                        msg.setStandardButtons(QMessageBox.Ok)
+                        msg.exec_()
+
+                        # Reset the grid cache for next run
+                        from napari_tmidas.processing_functions.grid_view_overlay import (
+                            reset_grid_cache,
+                        )
+
+                        reset_grid_cache()
+                except (FileNotFoundError, OSError, ValueError) as e:
+                    print(f"Could not load grid overlay: {e}")
+
     def processing_error(self, filepath, error_msg):
         """Handle processing errors"""
         print(f"Error processing {filepath}: {error_msg}")
@@ -1154,6 +2389,10 @@ class FileResultsWidget(QWidget):
 
     def cancel_processing(self):
         """Cancel the current processing operation"""
+        # Cancel any running cellpose subprocesses
+        if cancel_cellpose_processing:
+            cancel_cellpose_processing()
+
         if self.worker and self.worker.isRunning():
             self.worker.stop()
             self.worker.wait()  # Wait for the thread to finish