napari-tmidas 0.1.8.5__py3-none-any.whl → 0.2.0__py3-none-any.whl

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.8.5'
-__version_tuple__ = version_tuple = (0, 1, 8, 5)
+__version__ = version = '0.2.0'
+__version_tuple__ = version_tuple = (0, 2, 0)

napari_tmidas/processing_functions/basic.py

@@ -100,6 +100,66 @@ def max_z_projection(image: np.ndarray) -> np.ndarray:
     return (projection * max_val).clip(0, max_val).astype(image.dtype)
 
 
+@BatchProcessingRegistry.register(
+    name="Max Z Projection (TZYX)",
+    suffix="_maxZ_tzyx",
+    description="Maximum intensity projection along the Z-axis for TZYX data",
+    parameters={},  # No parameters needed - fully automatic
+)
+def max_z_projection_tzyx(image: np.ndarray) -> np.ndarray:
+    """
+    Memory-efficient maximum intensity projection along the Z-axis for TZYX data.
+
+    This function intelligently chooses the most memory-efficient approach
+    based on the input data size and available system memory.
+
+    Parameters:
+    -----------
+    image : numpy.ndarray
+        Input 4D image with TZYX dimensions
+
+    Returns:
+    --------
+    numpy.ndarray
+        3D image with TYX dimensions after max projection
+    """
+    # Validate input dimensions
+    if image.ndim != 4:
+        raise ValueError(f"Expected 4D image (TZYX), got {image.ndim}D image")
+
+    # Get dimensions
+    t_size, z_size, y_size, x_size = image.shape
+
+    # For Z projection, we only need one Z plane in memory at a time
+    # so we can process this plane by plane to minimize memory usage
+
+    # Create output array with appropriate dimensions and same dtype
+    result = np.zeros((t_size, y_size, x_size), dtype=image.dtype)
+
+    # Process each time point separately to minimize memory usage
+    for t in range(t_size):
+        # If data type allows direct max, use it
+        if np.issubdtype(image.dtype, np.integer) or np.issubdtype(
+            image.dtype, np.floating
+        ):
+            # Process Z planes efficiently
+            # Start with the first Z plane
+            z_max = image[t, 0].copy()
+
+            # Compare with each subsequent Z plane
+            for z in range(1, z_size):
+                # Use numpy's maximum function to update max values in-place
+                np.maximum(z_max, image[t, z], out=z_max)
+
+            # Store result for this time point
+            result[t] = z_max
+        else:
+            # For unusual data types, fall back to numpy's max function
+            result[t] = np.max(image[t], axis=0)
+
+    return result
+
+
 @BatchProcessingRegistry.register(
     name="Split Channels",
     suffix="_split_channels",

napari_tmidas/processing_functions/sam2_env_manager.py

@@ -0,0 +1,111 @@
+"""
+processing_functions/sam2_env_manager.py
+
+This module manages a dedicated virtual environment for SAM2.
+"""
+
+import os
+import platform
+import shutil
+import subprocess
+import venv
+
+# Define the environment directory in user's home folder
+ENV_DIR = os.path.join(
+    os.path.expanduser("~"), ".napari-tmidas", "envs", "sam2-env"
+)
+
+
+def is_sam2_installed():
+    """Check if SAM2 is installed in the current environment."""
+    try:
+        import importlib.util
+
+        return importlib.util.find_spec("sam2-env") is not None
+    except ImportError:
+        return False
+
+
+def is_env_created():
+    """Check if the dedicated environment exists."""
+    env_python = get_env_python_path()
+    return os.path.exists(env_python)
+
+
+def get_env_python_path():
+    """Get the path to the Python executable in the environment."""
+    if platform.system() == "Windows":
+        return os.path.join(ENV_DIR, "Scripts", "python.exe")
+    else:
+        return os.path.join(ENV_DIR, "bin", "python")
+
+
+def create_sam2_env():
+    """Create a dedicated virtual environment for SAM2."""
+    # Ensure the environment directory exists
+    os.makedirs(os.path.dirname(ENV_DIR), exist_ok=True)
+
+    # Remove existing environment if it exists
+    if os.path.exists(ENV_DIR):
+        shutil.rmtree(ENV_DIR)
+
+    print(f"Creating SAM2 environment at {ENV_DIR}...")
+
+    # Create a new virtual environment
+    venv.create(ENV_DIR, with_pip=True)
+
+    # Path to the Python executable in the new environment
+    env_python = get_env_python_path()
+
+    # Upgrade pip
+    print("Upgrading pip...")
+    subprocess.check_call(
+        [env_python, "-m", "pip", "install", "--upgrade", "pip"]
+    )
+
+    # Install numpy and torch first for compatibility
+    print("Installing torch and torchvision...")
+    subprocess.check_call(
+        [env_python, "-m", "pip", "install", "torch", "torchvision"]
+    )
+
+    # Install sam2 from GitHub
+    print("Installing SAM2 from GitHub...")
+    subprocess.check_call(
+        [
+            env_python,
+            "-m",
+            "pip",
+            "install",
+            "git+https://github.com/facebookresearch/sam2.git",
+        ]
+    )
+
+    subprocess.run(
+        [
+            env_python,
+            "-c",
+            "import torch; import torchvision; print('PyTorch version:', torch.__version__); print('Torchvision version:', torchvision.__version__); print('CUDA is available:', torch.cuda.is_available())",
+        ]
+    )
+
+    print("SAM2 environment created successfully.")
+    return env_python
+
+
+def run_sam2_in_env(func_name, args_dict):
+    """
+    Run SAM2 in a dedicated environment with minimal complexity.
+
+    Parameters:
+    -----------
+    func_name : str
+        Name of the SAM2 function to run (currently unused)
+    args_dict : dict
+        Dictionary of arguments for SAM2
+
+    Returns:
+    --------
+    numpy.ndarray
+        Segmentation masks
+    """

napari_tmidas/processing_functions/skimage_filters.py

@@ -16,6 +16,12 @@ except ImportError:
         "scikit-image not available, some processing functions will be disabled"
     )
 
+import contextlib
+import os
+
+import pandas as pd
+
+from napari_tmidas._file_selector import ProcessingWorker
 from napari_tmidas._registry import BatchProcessingRegistry
 
 if SKIMAGE_AVAILABLE:
@@ -114,6 +120,293 @@ if SKIMAGE_AVAILABLE:
             image, min_size=min_size
         )
 
+    @BatchProcessingRegistry.register(
+        name="Invert Image",
+        suffix="_inverted",
+        description="Invert pixel values in the image using scikit-image's invert function",
+    )
+    def invert_image(image: np.ndarray) -> np.ndarray:
+        """
+        Invert the image pixel values.
+
+        This function inverts the values in an image using scikit-image's invert function,
+        which handles different data types appropriately.
+
+        Parameters:
+        -----------
+        image : numpy.ndarray
+            Input image array
+
+        Returns:
+        --------
+        numpy.ndarray
+            Inverted image with the same data type as the input
+        """
+        # Make a copy to avoid modifying the original
+        image_copy = image.copy()
+
+        # Use skimage's invert function which handles all data types properly
+        return skimage.util.invert(image_copy)
+
+    @BatchProcessingRegistry.register(
+        name="Semantic to Instance Segmentation",
+        suffix="_instance",
+        description="Convert semantic segmentation masks to instance segmentation labels using connected components",
+    )
+    def semantic_to_instance(image: np.ndarray) -> np.ndarray:
+        """
+        Convert semantic segmentation masks to instance segmentation labels.
+
+        This function takes a binary or multi-class semantic segmentation mask and
+        converts it to an instance segmentation by finding connected components.
+        Each connected region receives a unique label.
+
+        Parameters:
+        -----------
+        image : numpy.ndarray
+            Input semantic segmentation mask
+
+        Returns:
+        --------
+        numpy.ndarray
+            Instance segmentation with unique labels for each connected component
+        """
+        # Create a copy to avoid modifying the original
+        instance_mask = image.copy()
+
+        # If the input is multi-class, process each class separately
+        if np.max(instance_mask) > 1:
+            # Get unique non-zero class values
+            class_values = np.unique(instance_mask)
+            class_values = class_values[
+                class_values > 0
+            ]  # Remove background (0)
+
+            # Create an empty output mask
+            result = np.zeros_like(instance_mask, dtype=np.uint32)
+
+            # Process each class
+            label_offset = 0
+            for class_val in class_values:
+                # Create binary mask for this class
+                binary_mask = (instance_mask == class_val).astype(np.uint8)
+
+                # Find connected components
+                labeled = skimage.measure.label(binary_mask, connectivity=2)
+
+                # Skip if no components found
+                if np.max(labeled) == 0:
+                    continue
+
+                # Add offset to avoid label overlap between classes
+                labeled[labeled > 0] += label_offset
+
+                # Add to result
+                result = np.maximum(result, labeled)
+
+                # Update offset for next class
+                label_offset = np.max(result)
+        else:
+            # For binary masks, just find connected components
+            result = skimage.measure.label(instance_mask > 0, connectivity=2)
+
+        return result.astype(np.uint32)
+
+    @BatchProcessingRegistry.register(
+        name="Extract Region Properties",
+        suffix="_props",  # Changed to indicate this is for CSV output only
+        description="Extract properties of labeled regions and save as CSV (no image output)",
+        parameters={
+            "properties": {
+                "type": str,
+                "default": "area,bbox,centroid,eccentricity,euler_number,perimeter",
+                "description": "Comma-separated list of properties to extract (e.g., area,perimeter,centroid)",
+            },
+            "intensity_image": {
+                "type": bool,
+                "default": False,
+                "description": "Use input as intensity image for intensity-based measurements",
+            },
+            "min_area": {
+                "type": int,
+                "default": 0,
+                "min": 0,
+                "max": 100000,
+                "description": "Minimum area to include in results (pixels)",
+            },
+        },
+    )
+    def extract_region_properties(
+        image: np.ndarray,
+        properties: str = "area,bbox,centroid,eccentricity,euler_number,perimeter",
+        intensity_image: bool = False,
+        min_area: int = 0,
+    ) -> np.ndarray:
+        """
+        Extract properties of labeled regions in an image and save results as CSV.
+
+        This function analyzes all labeled regions in a label image and computes
+        various region properties like area, perimeter, centroid, etc. The results
+        are saved as a CSV file. The input image is returned unchanged.
+
+        Parameters:
+        -----------
+        image : numpy.ndarray
+            Input label image (instance segmentation)
+        properties : str
+            Comma-separated list of properties to extract
+            See scikit-image documentation for all available properties:
+            https://scikit-image.org/docs/stable/api/skimage.measure.html#skimage.measure.regionprops
+        intensity_image : bool
+            Whether to use the input image as intensity image for intensity-based measurements
+        min_area : int
+            Minimum area (in pixels) for regions to include in results
+
+        Returns:
+        --------
+        numpy.ndarray
+            The original image (unchanged)
+        """
+        # Check if we have a proper label image
+        if image.ndim < 2 or np.max(image) == 0:
+            print(
+                "Input must be a valid label image with at least one labeled region"
+            )
+            return image
+
+        # Convert image to proper format for regionprops
+        label_image = image.astype(np.int32)
+
+        # Parse the properties list
+        prop_list = [prop.strip() for prop in properties.split(",")]
+
+        # Get region properties
+        if intensity_image:
+            # Use the same image as both label and intensity image
+            regions = skimage.measure.regionprops(
+                label_image, intensity_image=image
+            )
+        else:
+            regions = skimage.measure.regionprops(label_image)
+
+        # Collect property data
+        data = []
+        for region in regions:
+            # Skip regions that are too small
+            if region.area < min_area:
+                continue
+
+            # Get all requested properties
+            region_data = {"label": region.label}
+            for prop in prop_list:
+                try:
+                    value = getattr(region, prop)
+
+                    # Handle different types of properties
+                    if isinstance(value, tuple) or (
+                        isinstance(value, np.ndarray) and value.ndim > 0
+                    ):
+                        # For tuple/array properties like centroid, bbox, etc.
+                        if isinstance(value, tuple):
+                            value = np.array(value)
+
+                        # For each element in the tuple/array
+                        for i, val in enumerate(value):
+                            region_data[f"{prop}_{i}"] = val
+                    else:
+                        # For scalar properties like area, perimeter, etc.
+                        region_data[prop] = value
+                except AttributeError:
+                    print(f"Property '{prop}' not found, skipping")
+                    continue
+
+            data.append(region_data)
+
+        # Create a DataFrame
+        df = pd.DataFrame(data)
+
+        # Store the DataFrame as an attribute of the function
+        extract_region_properties.csv_data = df
+        extract_region_properties.save_csv = True
+        extract_region_properties.no_image_output = (
+            True  # Indicate no image output needed
+        )
+
+        print(f"Extracted properties for {len(data)} regions")
+        return image
+
+    # Monkey patch to handle saving CSV files without creating a new image file
+    try:
+        # Check if ProcessingWorker is imported and available
+        original_process_file = ProcessingWorker.process_file
+
+        # Create a new version that handles saving CSV
+        def process_file_with_csv_export(self, filepath):
+            """Modified process_file function that saves CSV after processing."""
+            result = original_process_file(self, filepath)
+
+            # Check if there's a result and if we should save CSV
+            if isinstance(result, dict) and "processed_file" in result:
+                output_path = result["processed_file"]
+
+                # Check if the processing function had CSV data
+                if (
+                    hasattr(self.processing_func, "save_csv")
+                    and self.processing_func.save_csv
+                    and hasattr(self.processing_func, "csv_data")
+                ):
+
+                    # Get the CSV data
+                    df = self.processing_func.csv_data
+
+                    # For functions that don't need an image output, use the original filepath
+                    # as the base for the CSV filename
+                    if (
+                        hasattr(self.processing_func, "no_image_output")
+                        and self.processing_func.no_image_output
+                    ):
+                        # Use the original filepath without creating a new image file
+                        base_path = os.path.splitext(filepath)[0]
+                        csv_path = f"{base_path}_regionprops.csv"
+
+                        # Don't save a duplicate image file
+                        if (
+                            os.path.exists(output_path)
+                            and output_path != filepath
+                        ):
+                            contextlib.suppress(OSError)
+                    else:
+                        # Create CSV filename from the output image path
+                        csv_path = (
+                            os.path.splitext(output_path)[0]
+                            + "_regionprops.csv"
+                        )
+
+                    # Save the CSV file
+                    df.to_csv(csv_path, index=False)
+                    print(f"Saved region properties to {csv_path}")
+
+                    # Add the CSV file to the result
+                    result["secondary_files"] = [csv_path]
+
+                    # If we don't need an image output, update the result to just point to the CSV
+                    if (
+                        hasattr(self.processing_func, "no_image_output")
+                        and self.processing_func.no_image_output
+                    ):
+                        result["processed_file"] = csv_path
+
+            return result
+
+        # Apply the monkey patch
+        ProcessingWorker.process_file = process_file_with_csv_export
+
+    except (NameError, AttributeError) as e:
+        print(f"Warning: Could not apply CSV export patch: {e}")
+        print(
+            "Region properties will be extracted but CSV files may not be saved"
+        )
+
 
 # binary to labels
 @BatchProcessingRegistry.register(

{napari_tmidas-0.1.8.5.dist-info → napari_tmidas-0.2.0.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: napari-tmidas
-Version: 0.1.8.5
-Summary: A plugin for batch processing of confocal microscopy images
+Version: 0.2.0
+Summary: A plugin for batch processing of confocal and whole-slide microscopy images of biological tissues
 Author: Marco Meer
 Author-email: marco.meer@pm.me
 License: 
@@ -83,42 +83,14 @@ Dynamic: license-file
 [![tests](https://github.com/macromeer/napari-tmidas/workflows/tests/badge.svg)](https://github.com/macromeer/napari-tmidas/actions)
 [![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) -->
-The `napari-tmidas` plugin consists of a growing collection of pipelines for fast batch processing of microscopy images. This is a WIP and based on the CLI version of [T-MIDAS](https://github.com/MercaderLabAnatomy/T-MIDAS).
-
-## Feature Overview
-
-1. **Image Processing**
-   - Process image folders with:
-     - Gamma correction & histogram equalization
-     - Z-projection and channel splitting
-     - Gaussian & median filters
-     - Thresholding (Otsu/manual)
-     - Label cleaning & binary conversion
-     - RGB to labels conversion
-     - Cellpose 3.0 automated segmentation
-     - File compression (Zstandard)
-
-2. **Label Inspection**
-   - Review and edit label images with auto-save
-
-3. **Microscopy Image Conversion**
-   - Convert .nd2/.lif/.ndpi/.czi/acquifer → .tif/.zarr with metadata preservation
-
-4. **Crop Anything**
-   - Interactive ROI selection via click interface
-
-5. **ROI Colocalization**
-   - Count colocalized labels across multiple channels
-
-
-
-### Coming Soon
-New features arriving April 2025
+The `napari-tmidas` plugin consists of a growing collection of pipelines for fast batch processing of confocal and whole slide microscopy images of biological tissues. This is a WIP and based on the CLI version of [T-MIDAS](https://github.com/MercaderLabAnatomy/T-MIDAS).
 
+## Features
+Currently, napari-tmidas provides pipelines as widgets for batch image conversion / cropping / processing, ROI colocalization and label inspection (cf. [Usage](#usage) below).
 
 ## Installation
 
-First install Napari in a virtual environment:
+First, install Napari in a virtual environment:
 
     mamba create -y -n napari-tmidas -c conda-forge python=3.11 tqdm
     mamba activate napari-tmidas
@@ -156,16 +128,15 @@ To use the plugin, start napari in the activated virtual environment with this t
 
     mamba run -n napari-tmidas napari
 
-You can find the installed plugin here:
-
-![image](https://github.com/user-attachments/assets/504db09a-d66e-49eb-90cd-3237024d9d7a)
-
+You can then find the installed plugin in the Plugins tab.
 
 ### Microscopy Image Conversion
 
 You can start this pipeline via `Plugins > T-MIDAS > Batch Microscopy Image Conversion`. Currently, this pipeline supports the conversion of `.nd2, .lif, .ndpi, .czi` and acquifer data. After scanning a folder of your choice for microscopy image data, select a file in the first column of the table and preview and export any image data it contains.
 
-![image](https://github.com/user-attachments/assets/e377ca71-2f30-447d-825e-d2feebf7061b)
+
+<img src="https://github.com/user-attachments/assets/e377ca71-2f30-447d-825e-d2feebf7061b" alt="Microscopy Image Conversion Widget" style="width:75%; height:auto;">
+
 
 ### Image Processing
 
@@ -173,7 +144,7 @@ You can start this pipeline via `Plugins > T-MIDAS > Batch Microscopy Image Conv
 
 ![image](https://github.com/user-attachments/assets/41ecb689-9abe-4371-83b5-9c5eb37069f9)
 
-2. As a result, a table appears with the found images.
+2. As a result, a table appears with the found images. You can click on them to inspect them in the viewer.
 
 ![image](https://github.com/user-attachments/assets/8360942a-be8f-49ec-bc25-385ee43bd601)
 
@@ -182,26 +153,28 @@ You can start this pipeline via `Plugins > T-MIDAS > Batch Microscopy Image Conv
 ![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.
+   
+<img src="https://github.com/user-attachments/assets/cfe84828-c1cc-4196-9a53-5dfb82d5bfce" alt="Image Processing Widget" style="width:75%; height:auto;">
 
-![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.
 
 ### Batch Label Inspection
 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 > Batch Label Inspection`, 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)
+<img src="https://github.com/user-attachments/assets/0bf8c6ae-4212-449d-8183-e91b23ba740e" alt="Batch Label Inspection Widget" style="width:75%; height:auto;">
+
 
 ### Crop Anything
 This pipeline combines the Segment Anything Model (SAM) for automatic object detection with an interactive interface for selecting and cropping multiple objects from images. To launch the widget, open `Plugins > T-MIDAS > Batch Crop Anything`. Click the image below to see a video demo.
 
-[![image](https://github.com/user-attachments/assets/6d72c2a2-1064-4a27-b398-a9b86fcbc443)](https://youtu.be/xPh0dRD_FbE)
+<img src="https://github.com/user-attachments/assets/6d72c2a2-1064-4a27-b398-a9b86fcbc443" alt="Crop Anything Widget" style="width:75%; height:auto;">
+
 
 ### ROI Colocalization
 This pipeline quantifies colocalization between labeled regions of interest (ROIs) across multiple image channels. It determines the extent of overlap between ROIs in a reference channel and those in one or two other channels. The output is a table of colocalization counts. Optionally, the size of reference channel ROIs, as well as the total or median size of colocalizing ROIs in the other channels, can be included. Colocalization is determined using Boolean masking. The number of colocalizing instances is determined by counting unique label IDs within the overlapping regions. Typically, the reference channel contains larger structures, while other channels contain smaller, potentially nested, structures. For example, the reference channel might contain cell bodies, with the second and third channels containing nuclei and sub-nuclear objects, respectively.
 
-![napari-tmidas_coloc_pipeline](https://github.com/user-attachments/assets/2f9022a0-7b88-4588-a448-250f07a634d7)
-
+<img src="https://github.com/user-attachments/assets/2f9022a0-7b88-4588-a448-250f07a634d7" alt="ROI Colocalization Widget" style="width:75%; height:auto;">
 
 ## Contributing
 

{napari_tmidas-0.1.8.5.dist-info → napari_tmidas-0.2.0.dist-info}/RECORD

@@ -2,12 +2,12 @@ napari_tmidas/__init__.py,sha256=YNBLESwk8jr_TlDdkSC1CwH0tf0CKHF1i2_efzLjdpk,589
 napari_tmidas/_crop_anything.py,sha256=NItpE6uzfeKujh8a53TDDkFN2thpKC5NGiXMpAmSnnM,45446
 napari_tmidas/_file_conversion.py,sha256=V6evJmggUwOFzJO203Y5ltboHXEWNJQckZPedGRkrLI,72203
 napari_tmidas/_file_selector.py,sha256=sZOY0QNwyAgugsEzG5pqZLfrVeCHwjPEW2C_BHndzyI,39595
-napari_tmidas/_label_inspection.py,sha256=hCxKE0zYk-qBh4ohqiZcEGLXa-3lL8p88y45p2WnE1g,7329
+napari_tmidas/_label_inspection.py,sha256=74V36y5EnGs0vWK1FC7Kui4CPLBW_SIg885PSKeZsJ4,9184
 napari_tmidas/_reader.py,sha256=A9_hdDxtVkVGmbOsbqgnARCSvpEh7GGPo7ylzmbnu8o,2485
 napari_tmidas/_registry.py,sha256=Oz9HFJh41MKRLeKxRuc7x7yzc-OrmoTdRFnfngFU_XE,2007
 napari_tmidas/_roi_colocalization.py,sha256=OVjdHvtFN07DgrtTX8uqbrxZL6jVwl2L3klorgW2C9k,43196
 napari_tmidas/_sample_data.py,sha256=khuv1jemz_fCjqNwEKMFf83Ju0EN4S89IKydsUMmUxw,645
-napari_tmidas/_version.py,sha256=c4rCUXy1zrstQ6YUlnpyulFDT5n9rZNVdxW9dQYyGe0,516
+napari_tmidas/_version.py,sha256=iB5DfB5V6YB5Wo4JmvS-txT42QtmGaWcWp3udRT7zCI,511
 napari_tmidas/_widget.py,sha256=u9uf9WILAwZg_InhFyjWInY4ej1TV1a59dR8Fe3vNF8,4794
 napari_tmidas/_writer.py,sha256=wbVfHFjjHdybSg37VR4lVmL-kdCkDZsUPDJ66AVLaFQ,1941
 napari_tmidas/napari.yaml,sha256=1Am1dA0-ZtCXk6veIT6jrMz3zwQ7dF8_p9tZTFx_vTg,2641
@@ -17,16 +17,17 @@ napari_tmidas/_tests/test_sample_data.py,sha256=D1HU_C3hWpO3mlSW_7Z94xaYHDtxz0XU
 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=TJFvJ9AfUp7MBseUAgryLJXdqj0gSLSKqlEPxE3s1n0,6694
+napari_tmidas/processing_functions/basic.py,sha256=kQcuA0_yPh6MwzkopcsBghcf3wMSR7uA1QDksS5SG2o,8761
 napari_tmidas/processing_functions/cellpose_env_manager.py,sha256=zngS5eborsJUimFn_g1Lm_YOZk2ZNIKxceWNxOjpxEg,4885
 napari_tmidas/processing_functions/cellpose_segmentation.py,sha256=7BCHj_QA1QJEl1NrsuoIFAJ040_SCWw0U-U_xjCyk18,16187
 napari_tmidas/processing_functions/colocalization.py,sha256=AiTTVAcVhKuuHZhrj5IHwbzns7-GE6ewvFqhYy1L-do,7657
 napari_tmidas/processing_functions/file_compression.py,sha256=mxR-yqBdc-T1XI3StIXpW8h5xGdCOtLQjt8uoRFpDSY,6859
+napari_tmidas/processing_functions/sam2_env_manager.py,sha256=WzKOLFeu1KZRRBryKdWkDm6QJolhs3rCj-KD6Q-z9dE,2897
 napari_tmidas/processing_functions/scipy_filters.py,sha256=kKpDAlQQ0ZNbkt77QUWi-Bwolk6MMDvtG_bZJV3MjOo,1612
-napari_tmidas/processing_functions/skimage_filters.py,sha256=6wSROKH71zwSFBOZ22zgp-4Nrq79GNd7znOitiH3Z3c,4030
-napari_tmidas-0.1.8.5.dist-info/licenses/LICENSE,sha256=tSjiOqj57exmEIfP2YVPCEeQf0cH49S6HheQR8IiY3g,1485
-napari_tmidas-0.1.8.5.dist-info/METADATA,sha256=bo5HfzWOBpQME6b-kkw7wkg71oQUjbU2hhN2D9lWwbA,11812
-napari_tmidas-0.1.8.5.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
-napari_tmidas-0.1.8.5.dist-info/entry_points.txt,sha256=fbVjzbJTm4aDMIBtel1Lyqvq-CwXY7wmCOo_zJ-jtRY,60
-napari_tmidas-0.1.8.5.dist-info/top_level.txt,sha256=63ybdxCZ4SeT13f_Ou4TsivGV_2Gtm_pJOXToAt30_E,14
-napari_tmidas-0.1.8.5.dist-info/RECORD,,
+napari_tmidas/processing_functions/skimage_filters.py,sha256=8UiXp5Wi7V-5prPZO-NgfkVi_kEYs7RUyINiCMxqTl0,15306
+napari_tmidas-0.2.0.dist-info/licenses/LICENSE,sha256=tSjiOqj57exmEIfP2YVPCEeQf0cH49S6HheQR8IiY3g,1485
+napari_tmidas-0.2.0.dist-info/METADATA,sha256=yUMPnhgtxQ3nN_uHvazNs8k7iEc9zUZxhTxCuF2Q9Jg,11560
+napari_tmidas-0.2.0.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
+napari_tmidas-0.2.0.dist-info/entry_points.txt,sha256=fbVjzbJTm4aDMIBtel1Lyqvq-CwXY7wmCOo_zJ-jtRY,60
+napari_tmidas-0.2.0.dist-info/top_level.txt,sha256=63ybdxCZ4SeT13f_Ou4TsivGV_2Gtm_pJOXToAt30_E,14
+napari_tmidas-0.2.0.dist-info/RECORD,,

{napari_tmidas-0.1.8.5.dist-info → napari_tmidas-0.2.0.dist-info}/WHEEL

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