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

napari_tmidas/__init__.py

@@ -3,14 +3,10 @@ try:
 except ImportError:
     __version__ = "unknown"
 
+
+from ._label_inspection import label_inspector_widget
 from ._reader import napari_get_reader
 from ._sample_data import make_sample_data
-from ._widget import (
-    ExampleQWidget,
-    ImageThreshold,
-    threshold_autogenerate_widget,
-    threshold_magic_widget,
-)
 from ._writer import write_multiple, write_single_image
 
 __all__ = (
@@ -18,8 +14,6 @@ __all__ = (
     "write_single_image",
     "write_multiple",
     "make_sample_data",
-    "ExampleQWidget",
-    "ImageThreshold",
-    "threshold_autogenerate_widget",
-    "threshold_magic_widget",
+    "file_selector",
+    "label_inspector_widget",
 )

napari_tmidas/_file_selector.py

@@ -0,0 +1,518 @@
+import contextlib
+import os
+import sys
+from typing import Any, Dict, List
+
+import napari
+import numpy as np
+import tifffile
+from magicgui import magicgui
+from qtpy.QtCore import Qt
+from qtpy.QtWidgets import (
+    QComboBox,
+    QDoubleSpinBox,
+    QFormLayout,
+    QHeaderView,
+    QLabel,
+    QLineEdit,
+    QPushButton,
+    QSpinBox,
+    QTableWidget,
+    QTableWidgetItem,
+    QVBoxLayout,
+    QWidget,
+)
+
+# Import registry and processing functions
+from napari_tmidas._registry import BatchProcessingRegistry
+
+sys.path.append("src/napari_tmidas")
+from napari_tmidas.processing_functions import (
+    discover_and_load_processing_functions,
+)
+
+
+class ProcessedFilesTableWidget(QTableWidget):
+    """
+    Custom table widget with lazy loading and processing capabilities
+    """
+
+    def __init__(self, viewer: napari.Viewer):
+        super().__init__()
+        self.viewer = viewer
+
+        # Configure table
+        self.setColumnCount(2)
+        self.setHorizontalHeaderLabels(["Original Files", "Processed Files"])
+        self.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
+
+        # Track file mappings
+        self.file_pairs = {}
+
+        # Currently loaded images
+        self.current_original_image = None
+        self.current_processed_image = None
+
+    def add_initial_files(self, file_list: List[str]):
+        """
+        Add initial files to the table
+        """
+        # Clear existing rows
+        self.setRowCount(0)
+        self.file_pairs.clear()
+
+        # Add files
+        for filepath in file_list:
+            row = self.rowCount()
+            self.insertRow(row)
+
+            # Original file item
+            original_item = QTableWidgetItem(os.path.basename(filepath))
+            original_item.setData(Qt.UserRole, filepath)
+            self.setItem(row, 0, original_item)
+
+            # Initially empty processed file column
+            processed_item = QTableWidgetItem("")
+            self.setItem(row, 1, processed_item)
+
+            # Store file pair
+            self.file_pairs[filepath] = {
+                "original": filepath,
+                "processed": None,
+                "row": row,
+            }
+
+    def update_processed_files(self, processing_info: dict):
+        """
+        Update table with processed files
+
+        processing_info: {
+            'original_file': original filepath,
+            'processed_file': processed filepath
+        }
+        """
+        for item in processing_info:
+            original_file = item["original_file"]
+            processed_file = item["processed_file"]
+
+            # Find the corresponding row
+            if original_file in self.file_pairs:
+                row = self.file_pairs[original_file]["row"]
+
+                # Update processed file column
+                processed_item = QTableWidgetItem(
+                    os.path.basename(processed_file)
+                )
+                processed_item.setData(Qt.UserRole, processed_file)
+                self.setItem(row, 1, processed_item)
+
+                # Update file pairs
+                self.file_pairs[original_file]["processed"] = processed_file
+
+    def mousePressEvent(self, event):
+        """
+        Load image when clicked
+        """
+        if event.button() == Qt.LeftButton:
+            item = self.itemAt(event.pos())
+            if item:
+                filepath = item.data(Qt.UserRole)
+                if filepath:
+                    # Determine which column was clicked
+                    column = self.columnAt(event.pos().x())
+                    if column == 0:
+                        # Original image clicked
+                        self._load_original_image(filepath)
+                    elif column == 1 and filepath:
+                        # Processed image clicked
+                        self._load_processed_image(filepath)
+
+        super().mousePressEvent(event)
+
+    def _load_original_image(self, filepath: str):
+        """
+        Load original image into viewer
+        """
+        # Remove existing original layer if it exists
+        if self.current_original_image is not None:
+            with contextlib.suppress(KeyError):
+                self.viewer.layers.remove(self.current_original_image)
+
+        # Load new image
+        try:
+            image = tifffile.imread(filepath)
+            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}"
+
+    def _load_processed_image(self, filepath: str):
+        """
+        Load processed image into viewer, distinguishing labels by filename pattern
+        """
+        # Remove existing processed layer if it exists
+        if self.current_processed_image is not None:
+            with contextlib.suppress(KeyError):
+                self.viewer.layers.remove(self.current_processed_image)
+
+        # Load new image
+        try:
+            image = tifffile.imread(filepath)
+            filename = os.path.basename(filepath)
+
+            # Check if filename contains label indicators
+            is_label = "labels" in filename or "semantic" in filename
+
+            # 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):
+                    image = image.astype(np.uint32)
+
+                self.current_processed_image = self.viewer.add_labels(
+                    image, name=f"Labels: {filename}"
+                )
+            else:
+                self.current_processed_image = self.viewer.add_image(
+                    image, name=f"Processed: {filename}"
+                )
+
+        except (ValueError, TypeError) as e:
+            print(f"Error loading processed image {filepath}: {e}")
+            self.viewer.status = f"Error processing {filepath}: {e}"
+
+    def _load_image(self, filepath: str):
+        """
+        Legacy method kept for compatibility
+        """
+        self._load_original_image(filepath)
+
+
+class ParameterWidget(QWidget):
+    """
+    Widget to display and edit processing function parameters
+    """
+
+    def __init__(self, parameters: Dict[str, Dict[str, Any]]):
+        super().__init__()
+
+        self.parameters = parameters
+        self.param_widgets = {}
+
+        layout = QFormLayout()
+        self.setLayout(layout)
+
+        # Create widgets for each parameter
+        for param_name, param_info in parameters.items():
+            param_type = param_info.get("type")
+            default_value = param_info.get("default")
+            min_value = param_info.get("min")
+            max_value = param_info.get("max")
+            description = param_info.get("description", "")
+
+            # Create appropriate widget based on parameter type
+            if param_type is int:
+                widget = QSpinBox()
+                if min_value is not None:
+                    widget.setMinimum(min_value)
+                if max_value is not None:
+                    widget.setMaximum(max_value)
+                if default_value is not None:
+                    widget.setValue(default_value)
+            elif param_type is float:
+                widget = QDoubleSpinBox()
+                if min_value is not None:
+                    widget.setMinimum(min_value)
+                if max_value is not None:
+                    widget.setMaximum(max_value)
+                widget.setDecimals(3)
+                if default_value is not None:
+                    widget.setValue(default_value)
+            else:
+                # Default to text input for other types
+                widget = QLineEdit(
+                    str(default_value) if default_value is not None else ""
+                )
+
+            # Add widget to layout with label
+            layout.addRow(f"{param_name} ({description}):", widget)
+            self.param_widgets[param_name] = widget
+
+    def get_parameter_values(self) -> Dict[str, Any]:
+        """
+        Get current parameter values from widgets
+        """
+        values = {}
+        for param_name, widget in self.param_widgets.items():
+            param_type = self.parameters[param_name]["type"]
+
+            if isinstance(widget, (QSpinBox, QDoubleSpinBox)):
+                values[param_name] = widget.value()
+            else:
+                # For text inputs, try to convert to the appropriate type
+                try:
+                    values[param_name] = param_type(widget.text())
+                except (ValueError, TypeError):
+                    # Fall back to string if conversion fails
+                    values[param_name] = widget.text()
+
+        return values
+
+
+@magicgui(
+    call_button="Find and Index Image Files",
+    input_folder={"label": "Select Folder"},
+    input_suffix={"label": "File Suffix (Example: _labels.tif)", "value": ""},
+)
+def file_selector(
+    viewer: napari.Viewer, input_folder: str, input_suffix: str = "_labels.tif"
+) -> List[str]:
+    """
+    Find files in a specified input folder with a given suffix and prepare for batch processing.
+    """
+    # Validate input_folder
+    if not os.path.isdir(input_folder):
+        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)
+    ]
+
+    # Create a results widget with batch processing option
+    results_widget = FileResultsWidget(
+        viewer,
+        matching_files,
+        input_folder=input_folder,
+        input_suffix=input_suffix,
+    )
+
+    # Add the results widget to the Napari viewer
+    viewer.window.add_dock_widget(
+        results_widget, name="Matching Files", area="right"
+    )
+
+    # Update viewer status
+    viewer.status = f"Found {len(matching_files)} files"
+
+    return matching_files
+
+
+class FileResultsWidget(QWidget):
+    """
+    Custom widget to display matching files and enable batch processing
+    """
+
+    def __init__(
+        self,
+        viewer: napari.Viewer,
+        file_list: List[str],
+        input_folder: str,
+        input_suffix: str,
+    ):
+        super().__init__()
+
+        # Store viewer and file list
+        self.viewer = viewer
+        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)
+
+        # Create main layout
+        layout = QVBoxLayout()
+        self.setLayout(layout)
+
+        # Create table of files
+        self.table = ProcessedFilesTableWidget(viewer)
+        self.table.add_initial_files(file_list)
+
+        # Add table to layout
+        layout.addWidget(self.table)
+
+        # Create processing function selector
+        processing_layout = QVBoxLayout()
+        processing_label = QLabel("Select Processing Function:")
+        processing_layout.addWidget(processing_label)
+
+        self.processing_selector = QComboBox()
+        self.processing_selector.addItems(
+            BatchProcessingRegistry.list_functions()
+        )
+        processing_layout.addWidget(self.processing_selector)
+
+        # Add description label
+        self.function_description = QLabel("")
+        processing_layout.addWidget(self.function_description)
+
+        # Create parameters section (will be populated when function is selected)
+        self.parameters_widget = QWidget()
+        processing_layout.addWidget(self.parameters_widget)
+
+        # Connect function selector to update parameters
+        self.processing_selector.currentTextChanged.connect(
+            self.update_function_info
+        )
+
+        # Optional output folder selector
+        output_layout = QVBoxLayout()
+        output_label = QLabel("Output Folder (optional):")
+        output_layout.addWidget(output_label)
+
+        self.output_folder = QLineEdit()
+        self.output_folder.setPlaceholderText(
+            "Leave blank to use source folder"
+        )
+        output_layout.addWidget(self.output_folder)
+
+        layout.addLayout(processing_layout)
+        layout.addLayout(output_layout)
+
+        # 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)
+
+        # Initialize parameters for the first function
+        if self.processing_selector.count() > 0:
+            self.update_function_info(self.processing_selector.currentText())
+
+    def update_function_info(self, function_name: str):
+        """
+        Update the function description and parameters when a new function is selected
+        """
+        function_info = BatchProcessingRegistry.get_function_info(
+            function_name
+        )
+        if not function_info:
+            return
+
+        # Update description
+        description = function_info.get("description", "")
+        self.function_description.setText(description)
+
+        # Update parameters
+        parameters = function_info.get("parameters", {})
+
+        # Remove old parameters widget if it exists
+        if hasattr(self, "param_widget_instance"):
+            self.parameters_widget.layout().removeWidget(
+                self.param_widget_instance
+            )
+            self.param_widget_instance.deleteLater()
+
+        # Create new layout if needed
+        if self.parameters_widget.layout() is None:
+            self.parameters_widget.setLayout(QVBoxLayout())
+
+        # Create and add new parameters widget
+        if parameters:
+            self.param_widget_instance = ParameterWidget(parameters)
+            self.parameters_widget.layout().addWidget(
+                self.param_widget_instance
+            )
+        else:
+            # Create empty widget if no parameters
+            self.param_widget_instance = QLabel(
+                "No parameters for this function"
+            )
+            self.parameters_widget.layout().addWidget(
+                self.param_widget_instance
+            )
+
+    def start_batch_processing(self):
+        """
+        Initiate batch processing of selected files
+        """
+        # Get selected processing function
+        selected_function_name = self.processing_selector.currentText()
+        function_info = BatchProcessingRegistry.get_function_info(
+            selected_function_name
+        )
+
+        if not function_info:
+            self.viewer.status = "No processing function selected"
+            return
+
+        processing_func = function_info["func"]
+        output_suffix = function_info["suffix"]
+
+        # Get parameter values if available
+        param_values = {}
+        if hasattr(self, "param_widget_instance") and hasattr(
+            self.param_widget_instance, "get_parameter_values"
+        ):
+            param_values = self.param_widget_instance.get_parameter_values()
+
+        # Determine output folder
+        output_folder = self.output_folder.text().strip()
+        if not output_folder:
+            output_folder = os.path.dirname(self.file_list[0])
+        else:
+            # make output folder a subfolder of the input folder
+            output_folder = os.path.join(self.input_folder, output_folder)
+
+        # 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}")
+
+        # Update table with processed files
+        self.table.update_processed_files(processed_files_info)
+
+        # Update viewer status
+        self.viewer.status = f"Processed {len(processed_files_info)} files with {selected_function_name}"
+
+
+def napari_experimental_provide_dock_widget():
+    """
+    Provide the file selector widget to Napari
+    """
+    return file_selector

napari_tmidas/_label_inspection.py

@@ -0,0 +1,160 @@
+import os
+import sys
+
+from magicgui import magicgui
+from napari.layers import Labels
+from napari.viewer import Viewer
+from skimage.io import imread, imsave
+
+sys.path.append("src/napari_tmidas")
+
+
+class LabelInspector:
+    def __init__(self, viewer: Viewer):
+        self.viewer = viewer
+        self.image_label_pairs = []
+        self.current_index = 0
+
+    def load_image_label_pairs(
+        self, folder_path: str, image_suffix: str, label_suffix: str
+    ):
+        """
+        Load image-label pairs from a folder.
+        """
+        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)]
+
+        # 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),
+                        )
+                    )
+                    break  # Match found, move to next image
+
+        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()
+
+    def _load_current_pair(self):
+        """
+        Load the current image-label pair into the Napari viewer.
+        """
+        if not self.image_label_pairs:
+            self.viewer.status = "No pairs to inspect."
+            return
+
+        image_path, label_path = self.image_label_pairs[self.current_index]
+        image = imread(image_path)
+        label_image = imread(label_path)
+
+        # Clear existing layers
+        self.viewer.layers.clear()
+
+        # Add the new layers
+        self.viewer.add_image(
+            image, name=f"Image ({os.path.basename(image_path)})"
+        )
+        self.viewer.add_labels(
+            label_image, name=f"Labels ({os.path.basename(label_path)})"
+        )
+
+    def save_current_labels(self):
+        """
+        Save the current labels back to the original file.
+        """
+        if not self.image_label_pairs:
+            self.viewer.status = "No pairs to save."
+            return
+
+        _, label_path = self.image_label_pairs[self.current_index]
+
+        # Find the labels layer in the viewer
+        labels_layer = next(
+            (
+                layer
+                for layer in self.viewer.layers
+                if isinstance(layer, Labels)
+            ),
+            None,
+        )
+
+        if labels_layer is None:
+            self.viewer.status = "No labels found."
+            return
+
+        # Save the labels layer data to the original file path
+        imsave(label_path, labels_layer.data.astype("uint16"))
+        self.viewer.status = f"Saved labels to {label_path}."
+
+    def next_pair(self):
+        """
+        Save changes and proceed to the next image-label pair.
+        """
+        if not self.image_label_pairs:
+            self.viewer.status = "No pairs to inspect."
+            return
+
+        # Save current labels before proceeding
+        self.save_current_labels()
+
+        # 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."
+            # should also clear the viewer
+            self.viewer.layers.clear()
+            return
+
+        # Move to the next pair
+        self.current_index += 1
+
+        # Load the next pair
+        self._load_current_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)"},
+)
+def label_inspector(
+    folder_path: str,
+    image_suffix: str,
+    label_suffix: str,
+    viewer: Viewer,
+):
+    """
+    MagicGUI widget for starting label inspection.
+    """
+    inspector = LabelInspector(viewer)
+    inspector.load_image_label_pairs(folder_path, image_suffix, label_suffix)
+
+    # Add buttons for saving and continuing to the next pair
+    @magicgui(call_button="Save Changes and Continue")
+    def save_and_continue():
+        inspector.next_pair()
+
+    viewer.window.add_dock_widget(save_and_continue)
+
+
+def label_inspector_widget():
+    """
+    Provide the label inspector widget to Napari
+    """
+    return label_inspector

napari_tmidas/_registry.py

@@ -0,0 +1,68 @@
+# napari_tmidas/_registry.py
+"""
+Registry for batch processing functions.
+"""
+from typing import Any, Dict, List, Optional
+
+
+class BatchProcessingRegistry:
+    """
+    A registry to manage and track available processing functions with parameter support
+    """
+
+    _processing_functions = {}
+
+    @classmethod
+    def register(
+        cls,
+        name: str,
+        suffix: str = "_processed",
+        description: str = "",
+        parameters: Optional[Dict[str, Dict[str, Any]]] = None,
+    ):
+        """
+        Decorator to register processing functions
+
+        Args:
+            name: Name of the processing function
+            suffix: Suffix to append to processed files
+            description: Description of what the function does
+            parameters: Dictionary of parameters with their metadata
+                {
+                    "param_name": {
+                        "type": type,
+                        "default": default_value,
+                        "min": min_value,  # optional, for numeric types
+                        "max": max_value,  # optional, for numeric types
+                        "description": "Parameter description"
+                    },
+                    ...
+                }
+        """
+        if parameters is None:
+            parameters = {}
+
+        def decorator(func):
+            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)
+
+    @classmethod
+    def list_functions(cls) -> List[str]:
+        """
+        List all registered processing function names
+        """
+        return list(cls._processing_functions.keys())

napari_tmidas/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.1.1'
-__version_tuple__ = version_tuple = (0, 1, 1)
+__version__ = version = '0.1.3'
+__version_tuple__ = version_tuple = (0, 1, 3)

napari_tmidas/napari.yaml

@@ -18,18 +18,12 @@ contributions:
     - id: napari-tmidas.make_sample_data
       python_name: napari_tmidas._sample_data:make_sample_data
       title: Load sample data from T-MIDAS
-    - id: napari-tmidas.make_container_widget
-      python_name: napari_tmidas:ImageThreshold
-      title: Make threshold Container widget
-    - id: napari-tmidas.make_magic_widget
-      python_name: napari_tmidas:threshold_magic_widget
-      title: Make threshold magic widget
-    - id: napari-tmidas.make_function_widget
-      python_name: napari_tmidas:threshold_autogenerate_widget
-      title: Make threshold function widget
-    - id: napari-tmidas.make_qwidget
-      python_name: napari_tmidas:ExampleQWidget
-      title: Make example QWidget
+    - id: napari-tmidas._label_inspection # hyphen!
+      python_name: napari_tmidas._label_inspection:label_inspector_widget # underscore!
+      title: Label inspector
+    - id: napari-tmidas.file_selector
+      python_name: napari_tmidas._file_selector:napari_experimental_provide_dock_widget
+      title: File selector
   readers:
     - command: napari-tmidas.get_reader
       accepts_directories: false
@@ -46,12 +40,7 @@ contributions:
       display_name: T-MIDAS
       key: unique_id.1
   widgets:
-    - command: napari-tmidas.make_container_widget
-      display_name: Container Threshold
-    - command: napari-tmidas.make_magic_widget
-      display_name: Magic Threshold
-    - command: napari-tmidas.make_function_widget
-      autogenerate: true
-      display_name: Autogenerate Threshold
-    - command: napari-tmidas.make_qwidget
-      display_name: Example QWidget
+    - command: napari-tmidas.file_selector
+      display_name: File selector
+    - command: napari-tmidas._label_inspection
+      display_name: Label inspector

napari_tmidas/processing_functions/__init__.py

@@ -0,0 +1,61 @@
+# processing_functions/__init__.py
+"""
+Package for processing functions that can be registered with the batch processing system.
+"""
+import importlib
+import os
+import pkgutil
+from typing import Dict, List
+
+# Keep the registry global
+from napari_tmidas._registry import BatchProcessingRegistry
+
+
+def discover_and_load_processing_functions() -> List[str]:
+    """
+    Discover and load all processing functions from the processing_functions package.
+
+    Returns:
+        List of registered function names
+    """
+    # Get the current package
+    package = __name__
+
+    # Find all modules in the package
+    for _, module_name, is_pkg in pkgutil.iter_modules(
+        [os.path.dirname(__file__)]
+    ):
+        if not is_pkg:  # Only load non-package modules
+            try:
+                # Import the module
+                importlib.import_module(f"{package}.{module_name}")
+                print(f"Loaded processing function module: {module_name}")
+            except ImportError as e:
+                # Log the error but continue with other modules
+                print(f"Failed to import {module_name}: {e}")
+
+    # Return the list of registered functions
+    return BatchProcessingRegistry.list_functions()
+
+
+def get_processing_function_info() -> Dict[str, Dict]:
+    """
+    Get information about all registered processing functions.
+
+    Returns:
+        Dictionary of function information
+    """
+    return {
+        name: {
+            "description": BatchProcessingRegistry.get_function_info(name).get(
+                "description", ""
+            ),
+            "suffix": BatchProcessingRegistry.get_function_info(name).get(
+                "suffix", ""
+            ),
+            "parameters": BatchProcessingRegistry.get_function_info(name).get(
+                "parameters", {}
+            ),
+        }
+        for name in BatchProcessingRegistry.list_functions()
+    }

napari_tmidas/processing_functions/basic.py

@@ -0,0 +1,60 @@
+# processing_functions/basic.py
+"""
+Basic image processing functions that don't require additional dependencies.
+"""
+import numpy as np
+
+from napari_tmidas._registry import BatchProcessingRegistry
+
+
+@BatchProcessingRegistry.register(
+    name="Min-Max Normalization",
+    suffix="_normalized",
+    description="Normalize image values to range [0, 1] using min-max scaling",
+)
+def normalize_image(image: np.ndarray) -> np.ndarray:
+    """
+    Simple min-max normalization
+    """
+    if image.min() == image.max():
+        return np.zeros_like(image, dtype=float)
+    return (image - image.min()) / (image.max() - image.min())
+
+
+@BatchProcessingRegistry.register(
+    name="Contrast Stretch",
+    suffix="_contrast",
+    description="Stretch the contrast by clipping percentiles and rescaling",
+    parameters={
+        "low_percentile": {
+            "type": float,
+            "default": 2.0,
+            "min": 0.0,
+            "max": 49.0,
+            "description": "Low percentile to clip",
+        },
+        "high_percentile": {
+            "type": float,
+            "default": 98.0,
+            "min": 51.0,
+            "max": 100.0,
+            "description": "High percentile to clip",
+        },
+    },
+)
+def contrast_stretch(
+    image: np.ndarray,
+    low_percentile: float = 2.0,
+    high_percentile: float = 98.0,
+) -> np.ndarray:
+    """
+    Stretch contrast by clipping percentiles
+    """
+    p_low = np.percentile(image, low_percentile)
+    p_high = np.percentile(image, high_percentile)
+
+    # Clip and normalize
+    image_clipped = np.clip(image, p_low, p_high)
+    if p_high == p_low:
+        return np.zeros_like(image, dtype=float)
+    return (image_clipped - p_low) / (p_high - p_low)

napari_tmidas/processing_functions/scipy_filters.py

@@ -0,0 +1,57 @@
+# processing_functions/scipy_filters.py
+"""
+Processing functions that depend on SciPy.
+"""
+import numpy as np
+
+try:
+    from scipy import ndimage
+
+    SCIPY_AVAILABLE = True
+except ImportError:
+    SCIPY_AVAILABLE = False
+    print("SciPy not available, some processing functions will be disabled")
+
+from napari_tmidas._registry import BatchProcessingRegistry
+
+if SCIPY_AVAILABLE:
+
+    @BatchProcessingRegistry.register(
+        name="Gaussian Blur",
+        suffix="_blurred",
+        description="Apply Gaussian blur to the image",
+        parameters={
+            "sigma": {
+                "type": float,
+                "default": 1.0,
+                "min": 0.1,
+                "max": 10.0,
+                "description": "Standard deviation for Gaussian kernel",
+            }
+        },
+    )
+    def gaussian_blur(image: np.ndarray, sigma: float = 1.0) -> np.ndarray:
+        """
+        Apply Gaussian blur to the image
+        """
+        return ndimage.gaussian_filter(image, sigma=sigma)
+
+    @BatchProcessingRegistry.register(
+        name="Median Filter",
+        suffix="_median",
+        description="Apply median filter for noise reduction",
+        parameters={
+            "size": {
+                "type": int,
+                "default": 3,
+                "min": 3,
+                "max": 15,
+                "description": "Size of the median filter window",
+            }
+        },
+    )
+    def median_filter(image: np.ndarray, size: int = 3) -> np.ndarray:
+        """
+        Apply median filter for noise reduction
+        """
+        return ndimage.median_filter(image, size=size)

napari_tmidas/processing_functions/skimage_filters.py

@@ -0,0 +1,113 @@
+# processing_functions/skimage_filters.py
+"""
+Processing functions that depend on scikit-image.
+"""
+import numpy as np
+
+try:
+    import skimage.exposure
+    import skimage.filters
+
+    SKIMAGE_AVAILABLE = True
+except ImportError:
+    SKIMAGE_AVAILABLE = False
+    print(
+        "scikit-image not available, some processing functions will be disabled"
+    )
+
+from napari_tmidas._registry import BatchProcessingRegistry
+
+if SKIMAGE_AVAILABLE:
+
+    @BatchProcessingRegistry.register(
+        name="Adaptive Histogram Equalization",
+        suffix="_clahe",
+        description="Enhance contrast using Contrast Limited Adaptive Histogram Equalization",
+        parameters={
+            "kernel_size": {
+                "type": int,
+                "default": 8,
+                "min": 4,
+                "max": 64,
+                "description": "Size of local region for histogram equalization",
+            },
+            "clip_limit": {
+                "type": float,
+                "default": 0.01,
+                "min": 0.001,
+                "max": 0.1,
+                "description": "Clipping limit for contrast enhancement",
+            },
+        },
+    )
+    def adaptive_hist_eq(
+        image: np.ndarray, kernel_size: int = 8, clip_limit: float = 0.01
+    ) -> np.ndarray:
+        """
+        Apply Contrast Limited Adaptive Histogram Equalization
+        """
+        # CLAHE expects image in [0, 1] range
+        img_norm = skimage.exposure.rescale_intensity(image, out_range=(0, 1))
+        return skimage.exposure.equalize_adapthist(
+            img_norm, kernel_size=kernel_size, clip_limit=clip_limit
+        )
+
+    @BatchProcessingRegistry.register(
+        name="Edge Detection",
+        suffix="_edges",
+        description="Detect edges using Sobel filter",
+    )
+    def edge_detection(image: np.ndarray) -> np.ndarray:
+        """
+        Detect edges using Sobel filter
+        """
+        return skimage.filters.sobel(image)
+
+    # simple otsu thresholding
+    @BatchProcessingRegistry.register(
+        name="Otsu Thresholding (semantic)",
+        suffix="_otsu_semantic",
+        description="Threshold image using Otsu's method",
+    )
+    def otsu_thresholding(image: np.ndarray) -> np.ndarray:
+        """
+        Threshold image using Otsu's method
+        """
+        thresh = skimage.filters.threshold_otsu(image)
+        return (image > thresh).astype(np.uint32)
+
+    # instance segmentation
+    @BatchProcessingRegistry.register(
+        name="Otsu Thresholding (instance)",
+        suffix="_otsu_labels",
+        description="Threshold image using Otsu's method",
+    )
+    def otsu_thresholding_instance(image: np.ndarray) -> np.ndarray:
+        """
+        Threshold image using Otsu's method
+        """
+        thresh = skimage.filters.threshold_otsu(image)
+        return skimage.measure.label(image > thresh).astype(np.uint32)
+
+    # simple thresholding
+    @BatchProcessingRegistry.register(
+        name="Manual Thresholding (8-bit)",
+        suffix="_thresh",
+        description="Threshold image using a fixed threshold",
+        parameters={
+            "threshold": {
+                "type": int,
+                "default": 128,
+                "min": 0,
+                "max": 255,
+                "description": "Threshold value",
+            },
+        },
+    )
+    def simple_thresholding(
+        image: np.ndarray, threshold: int = 128
+    ) -> np.ndarray:
+        """
+        Threshold image using a fixed threshold
+        """
+        return image > threshold

{napari_tmidas-0.1.1.dist-info → napari_tmidas-0.1.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: napari-tmidas
-Version: 0.1.1
+Version: 0.1.3
 Summary: Tissue Microscopy Image Data Analysis Suite
 Author: Marco Meer
 Author-email: marco.meer@pm.me
@@ -57,6 +57,7 @@ Requires-Dist: numpy
 Requires-Dist: magicgui
 Requires-Dist: qtpy
 Requires-Dist: scikit-image
+Requires-Dist: pyqt5
 Provides-Extra: testing
 Requires-Dist: tox; extra == "testing"
 Requires-Dist: pytest; extra == "testing"
@@ -71,34 +72,54 @@ Requires-Dist: pyqt5; extra == "testing"
 [![PyPI](https://img.shields.io/pypi/v/napari-tmidas.svg?color=green)](https://pypi.org/project/napari-tmidas)
 [![Python Version](https://img.shields.io/pypi/pyversions/napari-tmidas.svg?color=green)](https://python.org)
 [![tests](https://github.com/macromeer/napari-tmidas/workflows/tests/badge.svg)](https://github.com/macromeer/napari-tmidas/actions)
-[![codecov](https://codecov.io/gh/macromeer/napari-tmidas/branch/main/graph/badge.svg)](https://codecov.io/gh/macromeer/napari-tmidas)
 [![napari hub](https://img.shields.io/endpoint?url=https://api.napari-hub.org/shields/napari-tmidas)](https://napari-hub.org/plugins/napari-tmidas)
+<!-- [![codecov](https://codecov.io/gh/macromeer/napari-tmidas/branch/main/graph/badge.svg)](https://codecov.io/gh/macromeer/napari-tmidas) -->
 
-Tissue Microscopy Image Data Analysis Suite
+The Tissue Microscopy Image Data Analysis Suite (short: T-MIDAS), is a collection of pipelines for batch image preprocessing, segmentation, regions-of-interest (ROI) analysis and other useful features. This is a work in progress (WIP) and an evolutionary step away from the [terminal / command-line version of T-MIDAS](https://github.com/MercaderLabAnatomy/T-MIDAS).
 
-----------------------------------
+## Installation
 
-This [napari] plugin was generated with [copier] using the [napari-plugin-template].
+First install Napari in a virtual environment following the latest [Napari installation instructions](https://github.com/Napari/napari?tab=readme-ov-file#installation).
 
-<!--
-Don't miss the full getting started guide to set up your new package:
-https://github.com/napari/napari-plugin-template#getting-started
 
-and review the napari docs for plugin developers:
-https://napari.org/stable/plugins/index.html
--->
+After you have activated the environment, you can install `napari-tmidas` via [pip]:
 
-## Installation
+    pip install napari-tmidas
 
-You can install `napari-tmidas` via [pip]:
+To install the latest development version:
 
-    pip install napari-tmidas
+    pip install git+https://github.com/macromeer/napari-tmidas.git
 
+## Usage
 
+You can find the installed plugin here:
+   
+![image](https://github.com/user-attachments/assets/504db09a-d66e-49eb-90cd-3237024d9d7a)
 
-To install latest development version :
+### File inspector
 
-    pip install git+https://github.com/macromeer/napari-tmidas.git
+1. After opening `Plugins > T-MIDAS > File selector`, enter the path to the folder containing the images to be processed (currently supports TIF, later also ZARR). You can also filter for filename suffix.
+   
+![image](https://github.com/user-attachments/assets/41ecb689-9abe-4371-83b5-9c5eb37069f9)
+
+2. As a result, a table appears with the found images.
+   
+![image](https://github.com/user-attachments/assets/8360942a-be8f-49ec-bc25-385ee43bd601)
+
+3. Next, select a processing function, set parameters if applicable and `Start Batch Processing`.
+   
+![image](https://github.com/user-attachments/assets/05929660-6672-4f76-89da-4f17749ccfad)
+
+4. You can click on the images in the table to show them in the viewer. For example first click on one of the `Original Files`, and then the corresponding `Processed File` to see an overlay. 
+    
+![image](https://github.com/user-attachments/assets/cfe84828-c1cc-4196-9a53-5dfb82d5bfce)
+
+Note that whenever you click on an `Original File` or `Processed File` in the table, it will replace the one that is currently shown in the viewer. So naturally, you'd first select the original image, and then the processed image to correctly see the image pair that you want to inspect. 
+
+### Label inspector
+If you have already segmented a folder full of images and now you want to maybe inspect and edit each label image, you can use the `Plugins > T-MIDAS > Label inspector`, which automatically saves your changes to the existing label image once you click the `Save Changes and Continue` button (bottom right).
+
+![image](https://github.com/user-attachments/assets/0bf8c6ae-4212-449d-8183-e91b23ba740e)
 
 
 ## Contributing
@@ -128,6 +149,18 @@ If you encounter any problems, please [file an issue] along with a detailed desc
 
 [file an issue]: https://github.com/macromeer/napari-tmidas/issues
 
+----------------------------------
+
+This [napari] plugin was generated with [copier] using the [napari-plugin-template].
+
+<!--
+Don't miss the full getting started guide to set up your new package:
+https://github.com/napari/napari-plugin-template#getting-started
+
+and review the napari docs for plugin developers:
+https://napari.org/stable/plugins/index.html
+-->
+
 [napari]: https://github.com/napari/napari
 [tox]: https://tox.readthedocs.io/en/latest/
 [pip]: https://pypi.org/project/pip/

napari_tmidas-0.1.3.dist-info/RECORD

@@ -0,0 +1,25 @@
+napari_tmidas/__init__.py,sha256=Z9mznblUlUsRyH3d4k8SxUo4iXLMwJXURbq41QzhPpo,459
+napari_tmidas/_file_selector.py,sha256=YzjS-XIqLD8826n50KXAc0GfQeXOhvDs41QP3-bTtCU,17471
+napari_tmidas/_label_inspection.py,sha256=0icowMfyNRnaxgTIOi8KHxLXKfpfqtShIl8iVR4wJjc,4819
+napari_tmidas/_reader.py,sha256=A9_hdDxtVkVGmbOsbqgnARCSvpEh7GGPo7ylzmbnu8o,2485
+napari_tmidas/_registry.py,sha256=Oz9HFJh41MKRLeKxRuc7x7yzc-OrmoTdRFnfngFU_XE,2007
+napari_tmidas/_sample_data.py,sha256=khuv1jemz_fCjqNwEKMFf83Ju0EN4S89IKydsUMmUxw,645
+napari_tmidas/_version.py,sha256=NIzzV8ZM0W-CSLuEs1weG4zPrn_-8yr1AwwI1iuS6yo,511
+napari_tmidas/_widget.py,sha256=u9uf9WILAwZg_InhFyjWInY4ej1TV1a59dR8Fe3vNF8,4794
+napari_tmidas/_writer.py,sha256=wbVfHFjjHdybSg37VR4lVmL-kdCkDZsUPDJ66AVLaFQ,1941
+napari_tmidas/napari.yaml,sha256=Xmui3_7pxNxOkIFRWsZWuka56d6PXLQ2rl4XvMDl2aw,1839
+napari_tmidas/_tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+napari_tmidas/_tests/test_reader.py,sha256=gN_2StATLZYUL56X27ImJTVru_qSoFiY4vtgajcx3H0,975
+napari_tmidas/_tests/test_sample_data.py,sha256=D1HU_C3hWpO3mlSW_7Z94xaYHDtxz0XUrMjQoYop9Ag,104
+napari_tmidas/_tests/test_widget.py,sha256=I_d-Cra_CTcS0QdMItg_HMphvhj0XCx81JnFyCHk9lg,2204
+napari_tmidas/_tests/test_writer.py,sha256=4_MlZM9a5So74J16_4tIOJc6pwTOw9R0-oAE_YioIx4,122
+napari_tmidas/processing_functions/__init__.py,sha256=osXY9jSgDsrwFaS6ShPHP0wGRxMuX1mHRN9EDa9l41g,1891
+napari_tmidas/processing_functions/basic.py,sha256=g7tQ25UIxA26n6GBYcHlkSjUbv_lD-7x_Sd-ZvWbzUY,1711
+napari_tmidas/processing_functions/scipy_filters.py,sha256=kKpDAlQQ0ZNbkt77QUWi-Bwolk6MMDvtG_bZJV3MjOo,1612
+napari_tmidas/processing_functions/skimage_filters.py,sha256=RpBywSImAQc_L_0pysA3yAJlHHfZuqu6c3vokDv5p1I,3517
+napari_tmidas-0.1.3.dist-info/LICENSE,sha256=tSjiOqj57exmEIfP2YVPCEeQf0cH49S6HheQR8IiY3g,1485
+napari_tmidas-0.1.3.dist-info/METADATA,sha256=bXMq78n-Y-vWxw1W3zC9PHkG2-4KvIqxoUDXSNV72Yk,8222
+napari_tmidas-0.1.3.dist-info/WHEEL,sha256=beeZ86-EfXScwlR_HKu4SllMC9wUEj_8Z_4FJ3egI2w,91
+napari_tmidas-0.1.3.dist-info/entry_points.txt,sha256=fbVjzbJTm4aDMIBtel1Lyqvq-CwXY7wmCOo_zJ-jtRY,60
+napari_tmidas-0.1.3.dist-info/top_level.txt,sha256=63ybdxCZ4SeT13f_Ou4TsivGV_2Gtm_pJOXToAt30_E,14
+napari_tmidas-0.1.3.dist-info/RECORD,,

{napari_tmidas-0.1.1.dist-info → napari_tmidas-0.1.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.2)
+Generator: setuptools (76.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

napari_tmidas-0.1.1.dist-info/RECORD

@@ -1,18 +0,0 @@
-napari_tmidas/__init__.py,sha256=cVpVT4zJ5I9N6YFige0iySIMW3JzE35KKnEy-PFpFx0,592
-napari_tmidas/_reader.py,sha256=A9_hdDxtVkVGmbOsbqgnARCSvpEh7GGPo7ylzmbnu8o,2485
-napari_tmidas/_sample_data.py,sha256=khuv1jemz_fCjqNwEKMFf83Ju0EN4S89IKydsUMmUxw,645
-napari_tmidas/_version.py,sha256=Mmxse1R0ki5tjz9qzU8AQyqUsLt8nTyCAbYQp8R87PU,511
-napari_tmidas/_widget.py,sha256=u9uf9WILAwZg_InhFyjWInY4ej1TV1a59dR8Fe3vNF8,4794
-napari_tmidas/_writer.py,sha256=wbVfHFjjHdybSg37VR4lVmL-kdCkDZsUPDJ66AVLaFQ,1941
-napari_tmidas/napari.yaml,sha256=XRz2siVLEciSqUHv1tlLjX9BB0Sc1jBRB3KyAN2ISgA,2276
-napari_tmidas/_tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-napari_tmidas/_tests/test_reader.py,sha256=gN_2StATLZYUL56X27ImJTVru_qSoFiY4vtgajcx3H0,975
-napari_tmidas/_tests/test_sample_data.py,sha256=D1HU_C3hWpO3mlSW_7Z94xaYHDtxz0XUrMjQoYop9Ag,104
-napari_tmidas/_tests/test_widget.py,sha256=I_d-Cra_CTcS0QdMItg_HMphvhj0XCx81JnFyCHk9lg,2204
-napari_tmidas/_tests/test_writer.py,sha256=4_MlZM9a5So74J16_4tIOJc6pwTOw9R0-oAE_YioIx4,122
-napari_tmidas-0.1.1.dist-info/LICENSE,sha256=tSjiOqj57exmEIfP2YVPCEeQf0cH49S6HheQR8IiY3g,1485
-napari_tmidas-0.1.1.dist-info/METADATA,sha256=TuiFctic_XaF8TxYPQYuLJOlVTKiF_Qxl0Lh6SiYBb4,5850
-napari_tmidas-0.1.1.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-napari_tmidas-0.1.1.dist-info/entry_points.txt,sha256=fbVjzbJTm4aDMIBtel1Lyqvq-CwXY7wmCOo_zJ-jtRY,60
-napari_tmidas-0.1.1.dist-info/top_level.txt,sha256=63ybdxCZ4SeT13f_Ou4TsivGV_2Gtm_pJOXToAt30_E,14
-napari_tmidas-0.1.1.dist-info/RECORD,,