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

napari_tmidas/_file_selector.py

@@ -585,7 +585,8 @@ class ProcessingWorker(QThread):
                 filepath = future_to_file[future]
                 try:
                     result = future.result()
-                    if 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 (
@@ -611,6 +612,16 @@ class ProcessingWorker(QThread):
 
             print(f"Original image shape: {image.shape}, dtype: {image_dtype}")
 
+            # 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 = (
+                "timepoint" in function_name.lower()
+                or "merge" in function_name.lower()
+                or "folder" in function_name.lower()
+            )
+
             # Apply processing with parameters
             processed_image = self.processing_func(image, **self.param_values)
 
@@ -618,6 +629,19 @@ class ProcessingWorker(QThread):
                 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)
+            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
+                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)
@@ -939,9 +963,49 @@ class FileResultsWidget(QWidget):
 
         # Update description
         description = function_info.get("description", "")
-        self.function_description.setText(description)
 
-        # Update parameters
+        # Check if this is a folder-processing function that needs single threading
+        is_folder_function = (
+            "folder" in function_name.lower()
+            or "timepoint" in function_name.lower()
+            or "merge" in function_name.lower()
+            or "folder" in description.lower()
+            or "cellpose" in description.lower()
+            or "careamics" in description.lower()
+            or "trackastra" in description.lower()
+        )
+
+        # Disable threading controls for folder functions
+        if is_folder_function:
+            self.thread_count.setValue(1)
+            self.thread_count.setEnabled(False)
+            self.thread_count.setToolTip(
+                "This function processes entire folders and must run with 1 thread only."
+            )
+
+            # Add warning to description if not already present
+            if (
+                "IMPORTANT:" not in description
+                and "WARNING:" not in description
+            ):
+                description += "\nThis function has to run single-threaded."
+
+            self.function_description.setText(description)
+
+            # Change the description color to make it more prominent
+            self.function_description.setStyleSheet(
+                "QLabel { color: #ff6b00; font-weight: bold; }"
+            )
+        else:
+            # Re-enable threading controls for normal functions
+            self.thread_count.setEnabled(True)
+            self.thread_count.setToolTip(
+                "Number of threads to use for parallel processing"
+            )
+            self.function_description.setStyleSheet("")  # Reset styling
+            self.function_description.setText(description)
+
+        # Get parameters
         parameters = function_info.get("parameters", {})
 
         # Remove old parameters widget if it exists
@@ -1014,6 +1078,23 @@ class FileResultsWidget(QWidget):
         self.batch_button.setEnabled(False)
         self.cancel_button.setEnabled(True)
 
+        # Set thread count based on function properties
+        worker_thread_count = self.thread_count.value()
+
+        # Check if function should run single-threaded
+        if (
+            hasattr(processing_func, "thread_safe")
+            and not processing_func.thread_safe
+        ):
+            worker_thread_count = 1
+            self.viewer.status = (
+                "Processing with a single thread (function is not thread-safe)"
+            )
+        else:
+            self.viewer.status = (
+                f"Processing with {worker_thread_count} threads"
+            )
+
         # Create and start the worker thread
         self.worker = ProcessingWorker(
             self.file_list,
@@ -1024,8 +1105,8 @@ class FileResultsWidget(QWidget):
             output_suffix,
         )
 
-        # Set the thread count from the UI
-        self.worker.thread_count = self.thread_count.value()
+        # Set the thread count from the UI or function attribute
+        self.worker.thread_count = worker_thread_count
 
         # Connect signals
         self.worker.progress_updated.connect(self.update_progress)
@@ -1037,7 +1118,7 @@ class FileResultsWidget(QWidget):
         self.worker.start()
 
         # Update status
-        self.viewer.status = f"Processing {len(self.file_list)} files with {selected_function_name} using {self.thread_count.value()} threads"
+        self.viewer.status = f"Processing {len(self.file_list)} files with {selected_function_name} using {worker_thread_count} threads"
 
     def update_progress(self, value):
         """Update the progress bar"""

napari_tmidas/_label_inspection.py

@@ -11,10 +11,11 @@ Users can make and save changes to the labels, and proceed to the next pair.
 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, QPushButton
+from qtpy.QtWidgets import QFileDialog, QMessageBox, QPushButton
 from skimage.io import imread  # , imsave
 
 sys.path.append("src/napari_tmidas")
@@ -29,63 +30,105 @@ class LabelInspector:
     def load_image_label_pairs(self, folder_path: str, label_suffix: str):
         """
         Load image-label pairs from a folder.
-        Finds label files with the given suffix and matches them with their corresponding image files.
+        Finds all files with the given suffix and matches them with their corresponding image files.
+        Validates that label files are in the correct format.
         """
+        if not os.path.exists(folder_path) or not os.path.isdir(folder_path):
+            self.viewer.status = f"Folder path does not exist: {folder_path}"
+            return
+
         files = os.listdir(folder_path)
-        label_files = [file for file in files if file.endswith(label_suffix)]
 
-        # Extract the file extension (e.g., .tif)
-        file_extension = (
-            os.path.splitext(label_suffix)[-1] if "." in label_suffix else ""
-        )
+        # Find all files that contain the label suffix
+        # Using "in" instead of "endswith" for more flexibility
+        potential_label_files = [
+            file for file in files if label_suffix in file
+        ]
+
+        if not potential_label_files:
+            self.viewer.status = f"No files found with suffix '{label_suffix}'"
+            QMessageBox.warning(
+                None,
+                "No Label Files Found",
+                f"No files containing '{label_suffix}' were found in {folder_path}.",
+            )
+            return
 
-        # Modified matching logic
+        # Process all potential label files
         self.image_label_pairs = []
-        for lbl in label_files:
-            # Remove the label suffix to get the base name
-            label_prefix = lbl[: -len(label_suffix)]
-
-            # Potential corresponding image file
-            img = f"{label_prefix}{file_extension}"
-            img_path = os.path.join(folder_path, img)
-
-            # Check if the image file exists
-            if os.path.exists(img_path):
-                self.image_label_pairs.append(
-                    (
-                        img_path,
-                        os.path.join(folder_path, lbl),
-                    )
-                )
-                continue
-
-            # If not found, try finding any file that starts with the base name
+        skipped_files = []
+        format_issues = []
+
+        for label_file in potential_label_files:
+            label_path = os.path.join(folder_path, label_file)
+
+            # Get file extension
+            _, file_extension = os.path.splitext(label_file)
+
+            # Try to find a matching image file (everything before the label suffix)
+            base_name = label_file.split(label_suffix)[0]
+
+            # Look for potential images matching the base name
             potential_images = [
                 file
                 for file in files
-                if file.startswith(label_prefix)
+                if file.startswith(base_name)
+                and file != label_file
                 and file.endswith(file_extension)
-                and file != lbl
             ]
 
+            # If we found at least one potential image
             if potential_images:
-                # Use the first matching image
-                self.image_label_pairs.append(
-                    (
-                        os.path.join(folder_path, potential_images[0]),
-                        os.path.join(folder_path, lbl),
-                    )
-                )
-
-        if not self.image_label_pairs:
-            self.viewer.status = "No matching image-label pairs found."
-            return
-
-        self.viewer.status = (
-            f"Found {len(self.image_label_pairs)} image-label pairs."
-        )
-        self.current_index = 0
-        self._load_current_pair()
+                image_path = os.path.join(folder_path, potential_images[0])
+
+                # Validate label file format
+                try:
+                    label_data = imread(label_path)
+
+                    # Check if it looks like a label image (integer type)
+                    if not np.issubdtype(label_data.dtype, np.integer):
+                        format_issues.append(
+                            (label_file, "not an integer type")
+                        )
+                        continue
+
+                    # Add valid pair
+                    self.image_label_pairs.append((image_path, label_path))
+
+                except (
+                    FileNotFoundError,
+                    OSError,
+                    ValueError,
+                    Exception,
+                ) as e:
+                    skipped_files.append((label_file, str(e)))
+            else:
+                skipped_files.append((label_file, "no matching image found"))
+
+        # Report results
+        if self.image_label_pairs:
+            self.viewer.status = (
+                f"Found {len(self.image_label_pairs)} valid image-label pairs."
+            )
+            self.current_index = 0
+            self._load_current_pair()
+        else:
+            self.viewer.status = "No valid image-label pairs found."
+
+        # Show detailed report if there were issues
+        if skipped_files or format_issues:
+            msg = ""
+            if skipped_files:
+                msg += "Skipped files:\n"
+                for file, reason in skipped_files:
+                    msg += f"- {file}: {reason}\n"
+
+            if format_issues:
+                msg += "\nFormat issues:\n"
+                for file, issue in format_issues:
+                    msg += f"- {file}: {issue}\n"
+
+            QMessageBox.information(None, "Loading Report", msg)
 
     def _load_current_pair(self):
         """
@@ -110,6 +153,10 @@ class LabelInspector:
             label_image, name=f"Labels ({os.path.basename(label_path)})"
         )
 
+        # Show progress
+        total = len(self.image_label_pairs)
+        self.viewer.status = f"Viewing pair {self.current_index + 1} of {total}: {os.path.basename(image_path)}"
+
     def save_current_labels(self):
         """
         Save the current labels back to the original file.
@@ -172,7 +219,7 @@ class LabelInspector:
 @magicgui(
     call_button="Start Label Inspection",
     folder_path={"label": "Folder Path", "widget_type": "LineEdit"},
-    label_suffix={"label": "Label Suffix (e.g., _otsu_labels.tif)"},
+    label_suffix={"label": "Label Suffix (e.g., _labels.tif)"},
 )
 def label_inspector(
     folder_path: str,

napari_tmidas/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.1.9'
-__version_tuple__ = version_tuple = (0, 1, 9)
+__version__ = version = '0.2.1'
+__version_tuple__ = version_tuple = (0, 2, 1)