napari-tmidas 0.1.3__py3-none-any.whl → 0.1.4__py3-none-any.whl

napari_tmidas/_file_selector.py

@@ -1,3 +1,4 @@
+import concurrent.futures
 import contextlib
 import os
 import sys
@@ -7,14 +8,17 @@ import napari
 import numpy as np
 import tifffile
 from magicgui import magicgui
-from qtpy.QtCore import Qt
+from qtpy.QtCore import Qt, QThread, Signal
 from qtpy.QtWidgets import (
     QComboBox,
     QDoubleSpinBox,
+    QFileDialog,
     QFormLayout,
+    QHBoxLayout,
     QHeaderView,
     QLabel,
     QLineEdit,
+    QProgressBar,
     QPushButton,
     QSpinBox,
     QTableWidget,
@@ -22,6 +26,7 @@ from qtpy.QtWidgets import (
     QVBoxLayout,
     QWidget,
 )
+from skimage.io import imread
 
 # Import registry and processing functions
 from napari_tmidas._registry import BatchProcessingRegistry
@@ -140,10 +145,20 @@ class ProcessedFilesTableWidget(QTableWidget):
 
         # Load new image
         try:
-            image = tifffile.imread(filepath)
-            self.current_original_image = self.viewer.add_image(
-                image, name=f"Original: {os.path.basename(filepath)}"
-            )
+            image = imread(filepath)
+            # check if label image by checking file name
+            is_label = "labels" in os.path.basename(
+                filepath
+            ) or "semantic" in os.path.basename(filepath)
+            if is_label:
+                image = image.astype(np.uint32)
+                self.current_original_image = self.viewer.add_labels(
+                    image, name=f"Labels: {os.path.basename(filepath)}"
+                )
+            else:
+                self.current_original_image = self.viewer.add_image(
+                    image, name=f"Original: {os.path.basename(filepath)}"
+                )
         except (ValueError, TypeError, OSError, tifffile.TiffFileError) as e:
             print(f"Error loading original image {filepath}: {e}")
             self.viewer.status = f"Error processing {filepath}: {e}"
@@ -159,7 +174,7 @@ class ProcessedFilesTableWidget(QTableWidget):
 
         # Load new image
         try:
-            image = tifffile.imread(filepath)
+            image = imread(filepath)
             filename = os.path.basename(filepath)
 
             # Check if filename contains label indicators
@@ -263,11 +278,15 @@ class ParameterWidget(QWidget):
 
 @magicgui(
     call_button="Find and Index Image Files",
-    input_folder={"label": "Select Folder"},
-    input_suffix={"label": "File Suffix (Example: _labels.tif)", "value": ""},
+    input_folder={
+        "widget_type": "LineEdit",
+        "label": "Select Folder",
+        "value": "",
+    },
+    input_suffix={"label": "File Suffix (Example: .tif)", "value": ""},
 )
 def file_selector(
-    viewer: napari.Viewer, input_folder: str, input_suffix: str = "_labels.tif"
+    viewer: napari.Viewer, input_folder: str, input_suffix: str = ".tif"
 ) -> List[str]:
     """
     Find files in a specified input folder with a given suffix and prepare for batch processing.
@@ -303,6 +322,176 @@ 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
+    # parent = input_folder_widget.parentWidget()
+    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)
+
+
+# Processing worker for multithreading
+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
+
+    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 concurrent.futures.ThreadPoolExecutor() 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()
+                    if result:
+                        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"""
+        try:
+            # Load the image
+            image = imread(filepath)
+            image_dtype = image.dtype
+
+            # Apply processing with parameters
+            processed_image = self.processing_func(image, **self.param_values)
+
+            # Generate new filename
+            filename = os.path.basename(filepath)
+            name, ext = os.path.splitext(filename)
+            new_filename = (
+                name.replace(self.input_suffix, "") + self.output_suffix + ext
+            )
+            new_filepath = os.path.join(self.output_folder, new_filename)
+
+            # Save the processed image
+            if "labels" in new_filename or "semantic" in new_filename:
+                # processed_image = ndi.label(processed_image)[0]
+                tifffile.imwrite(
+                    new_filepath,
+                    processed_image.astype(np.uint32),
+                    compression="zlib",
+                )
+            else:
+                tifffile.imwrite(
+                    new_filepath,
+                    processed_image.astype(image_dtype),
+                    compression="zlib",
+                )
+
+            # Return processing info
+            return {"original_file": filepath, "processed_file": new_filepath}
+
+        except Exception:
+            # Re-raise to be caught by the executor
+            raise
+
+    def stop(self):
+        """Request worker to stop processing"""
+        self.stop_requested = True
+
+
 class FileResultsWidget(QWidget):
     """
     Custom widget to display matching files and enable batch processing
@@ -322,19 +511,20 @@ class FileResultsWidget(QWidget):
         self.file_list = file_list
         self.input_folder = input_folder
         self.input_suffix = input_suffix
-
-        # Load all processing functions
-        print("Calling discover_and_load_processing_functions")
-        discover_and_load_processing_functions()
-        # print what is found by discover_and_load_processing_functions
-        print("Available processing functions:")
-        for func_name in BatchProcessingRegistry.list_functions():
-            print(func_name)
+        self.worker = None  # Will hold the processing worker
 
         # Create main layout
         layout = QVBoxLayout()
         self.setLayout(layout)
 
+        # Input folder widgets
+        self.input_folder_widget = QLineEdit(self.input_folder)
+        layout.addWidget(self.input_folder_widget)
+
+        browse_button = QPushButton("Browse...")
+        browse_button.clicked.connect(self.browse_folder)
+        layout.addWidget(browse_button)
+
         # Create table of files
         self.table = ProcessedFilesTableWidget(viewer)
         self.table.add_initial_files(file_list)
@@ -342,6 +532,14 @@ class FileResultsWidget(QWidget):
         # Add table to layout
         layout.addWidget(self.table)
 
+        # Load all processing functions
+        print("Calling discover_and_load_processing_functions")
+        discover_and_load_processing_functions()
+        # print what is found by discover_and_load_processing_functions
+        print("Available processing functions:")
+        for func_name in BatchProcessingRegistry.list_functions():
+            print(func_name)
+
         # Create processing function selector
         processing_layout = QVBoxLayout()
         processing_label = QLabel("Select Processing Function:")
@@ -377,18 +575,88 @@ class FileResultsWidget(QWidget):
         )
         output_layout.addWidget(self.output_folder)
 
+        # Thread count selector
+        thread_layout = QHBoxLayout()
+        thread_label = QLabel("Number of threads:")
+        thread_layout.addWidget(thread_label)
+
+        self.thread_count = QSpinBox()
+        self.thread_count.setMinimum(1)
+        self.thread_count.setMaximum(
+            os.cpu_count() or 4
+        )  # Default to CPU count or 4
+        self.thread_count.setValue(
+            max(1, (os.cpu_count() or 4) - 1)
+        )  # Default to CPU count - 1
+        thread_layout.addWidget(self.thread_count)
+
+        output_layout.addLayout(thread_layout)
+
+        # Progress bar
+        self.progress_bar = QProgressBar()
+        self.progress_bar.setRange(0, 100)
+        self.progress_bar.setValue(0)
+        self.progress_bar.setVisible(False)  # Hide initially
+
         layout.addLayout(processing_layout)
         layout.addLayout(output_layout)
+        layout.addWidget(self.progress_bar)
+
+        # Add batch processing and cancel buttons
+        button_layout = QHBoxLayout()
 
-        # Add batch processing button
         self.batch_button = QPushButton("Start Batch Processing")
         self.batch_button.clicked.connect(self.start_batch_processing)
-        layout.addWidget(self.batch_button)
+        button_layout.addWidget(self.batch_button)
+
+        self.cancel_button = QPushButton("Cancel Processing")
+        self.cancel_button.clicked.connect(self.cancel_processing)
+        self.cancel_button.setEnabled(False)  # Disabled initially
+        button_layout.addWidget(self.cancel_button)
+
+        layout.addLayout(button_layout)
 
         # Initialize parameters for the first function
         if self.processing_selector.count() > 0:
             self.update_function_info(self.processing_selector.currentText())
 
+        # Container for tracking processed files during batch operation
+        self.processed_files_info = []
+
+    def browse_folder(self):
+        """
+        Open a file dialog to select a folder
+        """
+        folder = QFileDialog.getExistingDirectory(
+            self, "Select Folder", self.input_folder
+        )
+        if folder:
+            self.input_folder = folder
+            self.input_folder_widget.setText(folder)
+            self.validate_selected_folder(folder)
+
+    def validate_selected_folder(self, folder: str):
+        """
+        Validate the selected folder and update the file list
+        """
+        if not os.path.isdir(folder):
+            self.viewer.status = f"Invalid input folder: {folder}"
+            return
+
+        # Find matching files
+        matching_files = [
+            os.path.join(folder, f)
+            for f in os.listdir(folder)
+            if f.endswith(self.input_suffix)
+        ]
+
+        # Update table with new files
+        self.file_list = matching_files
+        self.table.add_initial_files(matching_files)
+
+        # Update viewer status
+        self.viewer.status = f"Found {len(matching_files)} files"
+
     def update_function_info(self, function_name: str):
         """
         Update the function description and parameters when a new function is selected
@@ -434,7 +702,7 @@ class FileResultsWidget(QWidget):
 
     def start_batch_processing(self):
         """
-        Initiate batch processing of selected files
+        Initiate multithreaded batch processing of selected files
         """
         # Get selected processing function
         selected_function_name = self.processing_selector.currentText()
@@ -467,48 +735,77 @@ class FileResultsWidget(QWidget):
         # Ensure output folder exists
         os.makedirs(output_folder, exist_ok=True)
 
-        # Track processed files
-        processed_files_info = []
-
-        # Process each file
-        for filepath in self.file_list:
-            try:
-                # Load the image
-                image = tifffile.imread(filepath)
-
-                # Apply processing with parameters
-                processed_image = processing_func(image, **param_values)
-
-                # Generate new filename
-                filename = os.path.basename(filepath)
-                name, ext = os.path.splitext(filename)
-                new_filename = (
-                    name.replace(self.input_suffix, "") + output_suffix + ext
-                )
-                new_filepath = os.path.join(output_folder, new_filename)
-
-                # Save processed image
-                tifffile.imwrite(new_filepath, processed_image)
-
-                # Track processed file
-                processed_files_info.append(
-                    {"original_file": filepath, "processed_file": new_filepath}
-                )
-
-            except (
-                ValueError,
-                TypeError,
-                OSError,
-                tifffile.TiffFileError,
-            ) as e:
-                self.viewer.status = f"Error processing {filepath}: {e}"
-                print(f"Error processing {filepath}: {e}")
+        # Reset progress tracking
+        self.progress_bar.setValue(0)
+        self.progress_bar.setVisible(True)
+        self.processed_files_info = []
+
+        # Update UI
+        self.batch_button.setEnabled(False)
+        self.cancel_button.setEnabled(True)
+
+        # Create and start the worker thread
+        self.worker = ProcessingWorker(
+            self.file_list,
+            processing_func,
+            param_values,
+            output_folder,
+            self.input_suffix,
+            output_suffix,
+        )
 
-        # Update table with processed files
-        self.table.update_processed_files(processed_files_info)
+        # Connect signals
+        self.worker.progress_updated.connect(self.update_progress)
+        self.worker.file_processed.connect(self.file_processed)
+        self.worker.processing_finished.connect(self.processing_finished)
+        self.worker.error_occurred.connect(self.processing_error)
+
+        # Start processing
+        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"
+
+    def update_progress(self, value):
+        """Update the progress bar"""
+        self.progress_bar.setValue(value)
+
+    def file_processed(self, result):
+        """Handle a processed file result"""
+        self.processed_files_info.append(result)
+        # Update table with this single processed file
+        self.table.update_processed_files([result])
+
+    def processing_finished(self):
+        """Handle processing completion"""
+        # Update UI
+        self.progress_bar.setValue(100)
+        self.batch_button.setEnabled(True)
+        self.cancel_button.setEnabled(False)
+
+        # Clean up worker
+        self.worker = None
+
+        # Update status
+        self.viewer.status = (
+            f"Completed processing {len(self.processed_files_info)} files"
+        )
 
-        # Update viewer status
-        self.viewer.status = f"Processed {len(processed_files_info)} files with {selected_function_name}"
+    def processing_error(self, filepath, error_msg):
+        """Handle processing errors"""
+        print(f"Error processing {filepath}: {error_msg}")
+        self.viewer.status = f"Error processing {filepath}: {error_msg}"
+
+    def cancel_processing(self):
+        """Cancel the current processing operation"""
+        if self.worker and self.worker.isRunning():
+            self.worker.stop()
+            self.worker.wait()  # Wait for the thread to finish
+
+            # Update UI
+            self.batch_button.setEnabled(True)
+            self.cancel_button.setEnabled(False)
+            self.viewer.status = "Processing cancelled"
 
 
 def napari_experimental_provide_dock_widget():

napari_tmidas/_label_inspection.py

@@ -4,7 +4,8 @@ import sys
 from magicgui import magicgui
 from napari.layers import Labels
 from napari.viewer import Viewer
-from skimage.io import imread, imsave
+from qtpy.QtWidgets import QFileDialog, QPushButton
+from skimage.io import imread  # , imsave
 
 sys.path.append("src/napari_tmidas")
 
@@ -15,31 +16,56 @@ class LabelInspector:
         self.image_label_pairs = []
         self.current_index = 0
 
-    def load_image_label_pairs(
-        self, folder_path: str, image_suffix: str, label_suffix: str
-    ):
+    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.
         """
         files = os.listdir(folder_path)
-        image_files = [file for file in files if file.endswith(image_suffix)]
         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 ""
+        )
+
         # Modified matching logic
         self.image_label_pairs = []
-        for img in image_files:
-            img_base = img[: -len(image_suffix)]  # Remove image suffix
-            for lbl in label_files:
-                if lbl.startswith(
-                    img_base
-                ):  # Check if label starts with image base
-                    self.image_label_pairs.append(
-                        (
-                            os.path.join(folder_path, img),
-                            os.path.join(folder_path, lbl),
-                        )
+        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),
                     )
-                    break  # Match found, move to next image
+                )
+                continue
+
+            # If not found, try finding any file that starts with the base name
+            potential_images = [
+                file
+                for file in files
+                if file.startswith(label_prefix)
+                and file.endswith(file_extension)
+                and file != lbl
+            ]
+
+            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."
@@ -99,7 +125,8 @@ class LabelInspector:
             return
 
         # Save the labels layer data to the original file path
-        imsave(label_path, labels_layer.data.astype("uint16"))
+        # imsave(label_path, labels_layer.data.astype("uint32"))
+        labels_layer.save(label_path)
         self.viewer.status = f"Saved labels to {label_path}."
 
     def next_pair(self):
@@ -115,27 +142,30 @@ class LabelInspector:
 
         # Check if we're already at the last pair
         if self.current_index >= len(self.image_label_pairs) - 1:
-            self.viewer.status = "No more pairs to inspect."
+            self.viewer.status = (
+                "No more pairs to inspect. Inspection complete."
+            )
             # should also clear the viewer
             self.viewer.layers.clear()
-            return
+            return False  # Return False to indicate we're at the end
 
         # Move to the next pair
         self.current_index += 1
 
         # Load the next pair
         self._load_current_pair()
+        return (
+            True  # Return True to indicate successful navigation to next pair
+        )
 
 
 @magicgui(
     call_button="Start Label Inspection",
-    folder_path={"label": "Folder Path"},
-    image_suffix={"label": "Image Suffix (e.g., .tif)"},
-    label_suffix={"label": "Label Suffix (e.g., _labels.tif)"},
+    folder_path={"label": "Folder Path", "widget_type": "LineEdit"},
+    label_suffix={"label": "Label Suffix (e.g., _otsu_labels.tif)"},
 )
 def label_inspector(
     folder_path: str,
-    image_suffix: str,
     label_suffix: str,
     viewer: Viewer,
 ):
@@ -143,11 +173,18 @@ def label_inspector(
     MagicGUI widget for starting label inspection.
     """
     inspector = LabelInspector(viewer)
-    inspector.load_image_label_pairs(folder_path, image_suffix, label_suffix)
+    inspector.load_image_label_pairs(folder_path, label_suffix)
 
     # Add buttons for saving and continuing to the next pair
     @magicgui(call_button="Save Changes and Continue")
     def save_and_continue():
+        # Check if we're at the last pair before proceeding
+        if inspector.current_index >= len(inspector.image_label_pairs) - 1:
+            save_and_continue.call_button.enabled = False
+            inspector.viewer.status = (
+                "All pairs processed. Inspection complete."
+            )
+            return
         inspector.next_pair()
 
     viewer.window.add_dock_widget(save_and_continue)
@@ -157,4 +194,28 @@ def label_inspector_widget():
     """
     Provide the label inspector widget to Napari
     """
-    return label_inspector
+    # Create the magicgui widget
+    widget = label_inspector
+
+    # Create and add browse button
+    browse_button = QPushButton("Browse...")
+
+    def on_browse_clicked():
+        folder = QFileDialog.getExistingDirectory(
+            None,
+            "Select Folder",
+            os.path.expanduser("~"),
+            QFileDialog.ShowDirsOnly | QFileDialog.DontResolveSymlinks,
+        )
+        if folder:
+            # Update the folder_path field
+            widget.folder_path.value = folder
+
+    browse_button.clicked.connect(on_browse_clicked)
+
+    # Insert the browse button next to the folder_path field
+    # Find the folder_path widget and its layout
+    folder_layout = widget.folder_path.native.parent().layout()
+    folder_layout.addWidget(browse_button)
+
+    return widget