napari-tmidas 0.1.9__tar.gz → 0.2.0__tar.gz

{napari_tmidas-0.1.9 → napari_tmidas-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: napari-tmidas
-Version: 0.1.9
+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

{napari_tmidas-0.1.9 → napari_tmidas-0.2.0}/src/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-0.1.9 → napari_tmidas-0.2.0}/src/napari_tmidas/_version.py

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

{napari_tmidas-0.1.9 → napari_tmidas-0.2.0}/src/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-0.2.0/src/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-0.2.0/src/napari_tmidas/processing_functions/skimage_filters.py

@@ -0,0 +1,427 @@
+# processing_functions/skimage_filters.py
+"""
+Processing functions that depend on scikit-image.
+"""
+import numpy as np
+
+try:
+    import skimage.exposure
+    import skimage.filters
+    import skimage.morphology
+
+    SKIMAGE_AVAILABLE = True
+except ImportError:
+    SKIMAGE_AVAILABLE = False
+    print(
+        "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:
+
+    # Equalize histogram
+    @BatchProcessingRegistry.register(
+        name="Equalize Histogram",
+        suffix="_equalized",
+        description="Equalize histogram of image",
+    )
+    def equalize_histogram(
+        image: np.ndarray, clip_limit: float = 0.01
+    ) -> np.ndarray:
+        """
+        Equalize histogram of image
+        """
+
+        return skimage.exposure.equalize_hist(image)
+
+    # simple otsu thresholding
+    @BatchProcessingRegistry.register(
+        name="Otsu Thresholding (semantic)",
+        suffix="_otsu_semantic",
+        description="Threshold image using Otsu's method to obtain a binary image",
+    )
+    def otsu_thresholding(image: np.ndarray) -> np.ndarray:
+        """
+        Threshold image using Otsu's method
+        """
+
+        image = skimage.img_as_ubyte(image)  # convert to 8-bit
+        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 to obtain a multi-label image",
+    )
+    def otsu_thresholding_instance(image: np.ndarray) -> np.ndarray:
+        """
+        Threshold image using Otsu's method
+        """
+        image = skimage.img_as_ubyte(image)  # convert to 8-bit
+        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 to obtain a binary image",
+        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
+        """
+        # convert to 8-bit
+        image = skimage.img_as_ubyte(image)
+        return image > threshold
+
+    # remove small objects
+    @BatchProcessingRegistry.register(
+        name="Remove Small Labels",
+        suffix="_rm_small",
+        description="Remove small labels from label images",
+        parameters={
+            "min_size": {
+                "type": int,
+                "default": 100,
+                "min": 1,
+                "max": 100000,
+                "description": "Remove labels smaller than: ",
+            },
+        },
+    )
+    def remove_small_objects(
+        image: np.ndarray, min_size: int = 100
+    ) -> np.ndarray:
+        """
+        Remove small labels from label images
+        """
+        return skimage.morphology.remove_small_objects(
+            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(
+    name="Binary to Labels",
+    suffix="_labels",
+    description="Convert binary images to label images (connected components)",
+)
+def binary_to_labels(image: np.ndarray) -> np.ndarray:
+    """
+    Convert binary images to label images (connected components)
+    """
+    # Make a copy of the input image to avoid modifying the original
+    label_image = image.copy()
+
+    # Convert binary image to label image using connected components
+    label_image = skimage.measure.label(label_image, connectivity=2)
+
+    return label_image

{napari_tmidas-0.1.9 → napari_tmidas-0.2.0}/src/napari_tmidas.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: napari-tmidas
-Version: 0.1.9
+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

{napari_tmidas-0.1.9 → napari_tmidas-0.2.0}/src/napari_tmidas.egg-info/SOURCES.txt

@@ -39,5 +39,6 @@ src/napari_tmidas/processing_functions/cellpose_env_manager.py
 src/napari_tmidas/processing_functions/cellpose_segmentation.py
 src/napari_tmidas/processing_functions/colocalization.py
 src/napari_tmidas/processing_functions/file_compression.py
+src/napari_tmidas/processing_functions/sam2_env_manager.py
 src/napari_tmidas/processing_functions/scipy_filters.py
 src/napari_tmidas/processing_functions/skimage_filters.py

napari_tmidas-0.1.9/src/napari_tmidas/processing_functions/skimage_filters.py

@@ -1,134 +0,0 @@
-# processing_functions/skimage_filters.py
-"""
-Processing functions that depend on scikit-image.
-"""
-import numpy as np
-
-try:
-    import skimage.exposure
-    import skimage.filters
-    import skimage.morphology
-
-    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:
-
-    # Equalize histogram
-    @BatchProcessingRegistry.register(
-        name="Equalize Histogram",
-        suffix="_equalized",
-        description="Equalize histogram of image",
-    )
-    def equalize_histogram(
-        image: np.ndarray, clip_limit: float = 0.01
-    ) -> np.ndarray:
-        """
-        Equalize histogram of image
-        """
-
-        return skimage.exposure.equalize_hist(image)
-
-    # simple otsu thresholding
-    @BatchProcessingRegistry.register(
-        name="Otsu Thresholding (semantic)",
-        suffix="_otsu_semantic",
-        description="Threshold image using Otsu's method to obtain a binary image",
-    )
-    def otsu_thresholding(image: np.ndarray) -> np.ndarray:
-        """
-        Threshold image using Otsu's method
-        """
-
-        image = skimage.img_as_ubyte(image)  # convert to 8-bit
-        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 to obtain a multi-label image",
-    )
-    def otsu_thresholding_instance(image: np.ndarray) -> np.ndarray:
-        """
-        Threshold image using Otsu's method
-        """
-        image = skimage.img_as_ubyte(image)  # convert to 8-bit
-        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 to obtain a binary image",
-        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
-        """
-        # convert to 8-bit
-        image = skimage.img_as_ubyte(image)
-        return image > threshold
-
-    # remove small objects
-    @BatchProcessingRegistry.register(
-        name="Remove Small Labels",
-        suffix="_rm_small",
-        description="Remove small labels from label images",
-        parameters={
-            "min_size": {
-                "type": int,
-                "default": 100,
-                "min": 1,
-                "max": 100000,
-                "description": "Remove labels smaller than: ",
-            },
-        },
-    )
-    def remove_small_objects(
-        image: np.ndarray, min_size: int = 100
-    ) -> np.ndarray:
-        """
-        Remove small labels from label images
-        """
-        return skimage.morphology.remove_small_objects(
-            image, min_size=min_size
-        )
-
-
-# binary to labels
-@BatchProcessingRegistry.register(
-    name="Binary to Labels",
-    suffix="_labels",
-    description="Convert binary images to label images (connected components)",
-)
-def binary_to_labels(image: np.ndarray) -> np.ndarray:
-    """
-    Convert binary images to label images (connected components)
-    """
-    # Make a copy of the input image to avoid modifying the original
-    label_image = image.copy()
-
-    # Convert binary image to label image using connected components
-    label_image = skimage.measure.label(label_image, connectivity=2)
-
-    return label_image