napari-tmidas 0.2.1__py3-none-any.whl → 0.2.4__py3-none-any.whl

napari_tmidas/_label_inspection.py

@@ -12,11 +12,49 @@ import os
 import sys
 
 import numpy as np
-from magicgui import magicgui
-from napari.layers import Labels
-from napari.viewer import Viewer
-from qtpy.QtWidgets import QFileDialog, QMessageBox, QPushButton
-from skimage.io import imread  # , imsave
+
+# Lazy imports for optional heavy dependencies
+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 napari.layers import Labels
+    from napari.viewer import Viewer
+
+    _HAS_NAPARI = True
+except ImportError:
+    Labels = None
+    Viewer = None
+    _HAS_NAPARI = False
+
+try:
+    from qtpy.QtWidgets import QFileDialog, QMessageBox, QPushButton
+
+    _HAS_QTPY = True
+except ImportError:
+    QFileDialog = QMessageBox = QPushButton = None
+    _HAS_QTPY = False
+
+try:
+    from skimage.io import imread  # , imsave
+
+    _HAS_SKIMAGE = True
+except ImportError:
+    imread = None
+    _HAS_SKIMAGE = False
 
 sys.path.append("src/napari_tmidas")
 
@@ -27,6 +65,43 @@ class LabelInspector:
         self.image_label_pairs = []
         self.current_index = 0
 
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+    def _can_show_message(self) -> bool:
+        """Return True if it's (probably) safe to show a QMessageBox.
+
+        On Windows CI (headless) creating a modal dialog without a running
+        QApplication or with a mocked viewer can cause access violations.
+        We suppress dialogs when:
+          * No QApplication instance exists
+          * Running under pytest (detected via env var)
+          * The provided viewer is a mock (has no 'window' attr)
+        """
+        try:
+            from qtpy.QtWidgets import QApplication
+
+            if QApplication.instance() is None:
+                return False
+        except (ImportError, RuntimeError):
+            return False
+        if "PYTEST_CURRENT_TEST" in os.environ:
+            return False
+        return hasattr(self.viewer, "window")
+
+    def _show_message(self, level: str, title: str, text: str):
+        """Safely show a QMessageBox if environment allows, otherwise noop."""
+        if not self._can_show_message():
+            return
+        try:
+            if level == "warning":
+                QMessageBox.warning(None, title, text)
+            else:
+                QMessageBox.information(None, title, text)
+        except (RuntimeError, ValueError, OSError):
+            # Never let common GUI/runtime issues crash tests
+            pass
+
     def load_image_label_pairs(self, folder_path: str, label_suffix: str):
         """
         Load image-label pairs from a folder.
@@ -47,8 +122,8 @@ class LabelInspector:
 
         if not potential_label_files:
             self.viewer.status = f"No files found with suffix '{label_suffix}'"
-            QMessageBox.warning(
-                None,
+            self._show_message(
+                "warning",
                 "No Label Files Found",
                 f"No files containing '{label_suffix}' were found in {folder_path}.",
             )
@@ -128,7 +203,7 @@ class LabelInspector:
                 for file, issue in format_issues:
                     msg += f"- {file}: {issue}\n"
 
-            QMessageBox.information(None, "Loading Report", msg)
+            self._show_message("info", "Loading Report", msg)
 
     def _load_current_pair(self):
         """

napari_tmidas/_processing_worker.py

@@ -0,0 +1,309 @@
+"""
+Processing worker for batch image processing.
+"""
+
+import concurrent.futures
+import os
+from typing import Any, List, Union
+
+import numpy as np
+
+# Lazy imports for optional heavy dependencies
+try:
+    import tifffile
+
+    _HAS_TIFFFILE = True
+except ImportError:
+    tifffile = None
+    _HAS_TIFFFILE = False
+
+try:
+    from qtpy.QtCore import QThread, Signal
+
+    _HAS_QTPY = True
+except ImportError:
+    # Create stubs to allow class definitions
+    class QThread:
+        def __init__(self):
+            pass
+
+        def run(self):
+            pass
+
+    def Signal(*args):
+        return None
+
+    _HAS_QTPY = False
+
+
+class ProcessingWorker(QThread):
+    """
+    Worker thread for processing images in the background
+    """
+
+    # Signals to communicate with the main thread
+    progress_updated = Signal(int)
+    file_processed = Signal(dict)
+    processing_finished = Signal()
+    error_occurred = Signal(str, str)  # filepath, error message
+
+    def __init__(
+        self,
+        file_list,
+        processing_func,
+        param_values,
+        output_folder,
+        input_suffix,
+        output_suffix,
+    ):
+        super().__init__()
+        self.file_list = file_list
+        self.processing_func = processing_func
+        self.param_values = param_values
+        self.output_folder = output_folder
+        self.input_suffix = input_suffix
+        self.output_suffix = output_suffix
+        self.stop_requested = False
+        self.thread_count = max(1, (os.cpu_count() or 4) - 1)  # Default value
+
+    def stop(self):
+        """Request the worker to stop processing"""
+        self.stop_requested = True
+
+    def run(self):
+        """Process files in a separate thread"""
+        # Track processed files
+        processed_files_info = []
+        total_files = len(self.file_list)
+
+        # Create a thread pool for concurrent processing with specified thread count
+        with concurrent.futures.ThreadPoolExecutor(
+            max_workers=self.thread_count
+        ) as executor:
+            # Submit tasks
+            future_to_file = {
+                executor.submit(self.process_file, filepath): filepath
+                for filepath in self.file_list
+            }
+
+            # Process as they complete
+            for i, future in enumerate(
+                concurrent.futures.as_completed(future_to_file)
+            ):
+                # Check if cancellation was requested
+                if self.stop_requested:
+                    break
+
+                filepath = future_to_file[future]
+                try:
+                    result = future.result()
+                    # Only process result if it's not None (folder functions may return None)
+                    if result is not None:
+                        processed_files_info.append(result)
+                        self.file_processed.emit(result)
+                except (
+                    ValueError,
+                    TypeError,
+                    OSError,
+                    tifffile.TiffFileError,
+                ) as e:
+                    self.error_occurred.emit(filepath, str(e))
+
+                # Update progress
+                self.progress_updated.emit(int((i + 1) / total_files * 100))
+
+        # Signal that processing is complete
+        self.processing_finished.emit()
+
+    def process_file(self, filepath):
+        """Process a single file with support for large TIFF and Zarr files"""
+        try:
+            # Load the image using the unified loader
+            image_data = load_image_file(filepath)
+
+            # 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
+                        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
+
+            # Check if this is a folder-processing function that shouldn't save individual files
+            function_name = getattr(
+                self.processing_func, "__name__", "unknown"
+            )
+            is_folder_function = function_name in [
+                "merge_timepoints",
+                "track_objects",
+                "create_grid_overlay",  # Grid overlay processes all files at once
+            ]
+
+            # Only print verbose output for non-folder functions
+            if not is_folder_function:
+                print(
+                    f"Original image shape: {image.shape if hasattr(image, 'shape') else 'unknown'}, dtype: {image_dtype}"
+                )
+
+            # Apply the processing function with parameters
+            if self.param_values:
+                processed_image = self.processing_func(
+                    image, **self.param_values
+                )
+            else:
+                processed_image = self.processing_func(image)
+
+            # Handle functions that return multiple outputs (e.g., channel splitting)
+            if (
+                isinstance(processed_image, (list, tuple))
+                and len(processed_image) > 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_image) == 3
+                    and self.output_suffix == "_layer"
+                ):
+                    layer_names = [
+                        "_inner",
+                        "_middle",
+                        "_outer",
+                    ]
+                    for img, layer_name in zip(processed_image, layer_names):
+                        if not isinstance(img, np.ndarray):
+                            continue
+
+                        # Generate output filename with layer name
+                        output_filename = f"{base_name}{layer_name}.tif"
+                        output_path = os.path.join(
+                            self.output_folder, output_filename
+                        )
+
+                        # 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)
+                    for idx, img in enumerate(processed_image):
+                        if not isinstance(img, np.ndarray):
+                            continue
+
+                        # Generate output filename
+                        output_filename = (
+                            f"{base_name}_ch{idx + 1}{self.output_suffix}"
+                        )
+                        output_path = os.path.join(
+                            self.output_folder, output_filename
+                        )
+
+                        # Save the processed image
+                        save_image_file(img, output_path, image_dtype)
+                        processed_files.append(output_path)
+
+                return {
+                    "original_file": filepath,
+                    "processed_files": processed_files,
+                }
+
+            elif processed_image is not None and not is_folder_function:
+                # Single output - save as single file
+                base_name = os.path.splitext(os.path.basename(filepath))[0]
+                output_filename = f"{base_name}{self.output_suffix}"
+                output_path = os.path.join(self.output_folder, output_filename)
+
+                # Save the processed image
+                save_image_file(processed_image, output_path, image_dtype)
+
+                return {
+                    "original_file": filepath,
+                    "processed_file": output_path,
+                }
+
+            else:
+                # Folder function or no output to save
+                return {
+                    "original_file": filepath,
+                    "processed_file": None,
+                }
+
+        except Exception as e:
+            print(f"Error processing {filepath}: {e}")
+            import traceback
+
+            traceback.print_exc()
+            raise
+
+
+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
+    """
+    # This is a placeholder - the actual implementation would be moved from _file_selector.py
+    # For now, return a dummy array
+    return np.random.rand(100, 100)
+
+
+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):
+    """
+    Save image to file with proper format detection.
+
+    Label images are saved as uint32 to ensure napari recognizes them as labels.
+    Napari automatically detects int32/uint32/int64/uint64 dtypes as labels.
+    """
+    if not _HAS_TIFFFILE:
+        raise ImportError("tifffile is required to save images")
+
+    # Calculate approx file size in GB
+    size_gb = image.size * image.itemsize / (1024**3)
+
+    # For very large files, use BigTIFF format
+    use_bigtiff = size_gb > 2.0
+
+    # 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
+        # uint32 is the standard for label images and is automatically
+        # recognized by napari
+        save_dtype = np.uint32
+    else:
+        # Use image's dtype
+        save_dtype = image.dtype
+
+    tifffile.imwrite(
+        filepath,
+        image.astype(save_dtype),
+        compression="zlib",
+        bigtiff=use_bigtiff,
+    )

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):

napari_tmidas/_registry.py

@@ -2,6 +2,7 @@
 """
 Registry for batch processing functions.
 """
+import threading
 from typing import Any, Dict, List, Optional
 
 
@@ -11,6 +12,7 @@ class BatchProcessingRegistry:
     """
 
     _processing_functions = {}
+    _lock = threading.RLock()  # Add thread lock
 
     @classmethod
     def register(
@@ -43,26 +45,25 @@ class BatchProcessingRegistry:
             parameters = {}
 
         def decorator(func):
-            cls._processing_functions[name] = {
-                "func": func,
-                "suffix": suffix,
-                "description": description,
-                "parameters": parameters,
-            }
+            with cls._lock:  # Thread-safe registration
+                cls._processing_functions[name] = {
+                    "func": func,
+                    "suffix": suffix,
+                    "description": description,
+                    "parameters": parameters,
+                }
             return func
 
         return decorator
 
     @classmethod
     def get_function_info(cls, name: str) -> Optional[dict]:
-        """
-        Retrieve a registered processing function and its metadata
-        """
-        return cls._processing_functions.get(name)
+        """Thread-safe retrieval"""
+        with cls._lock:
+            return cls._processing_functions.get(name)
 
     @classmethod
     def list_functions(cls) -> List[str]:
-        """
-        List all registered processing function names
-        """
-        return list(cls._processing_functions.keys())
+        """Thread-safe listing, returns alphabetically sorted list"""
+        with cls._lock:
+            return sorted(cls._processing_functions.keys())