napari-tmidas 0.1.6__py3-none-any.whl → 0.1.7__py3-none-any.whl

napari_tmidas/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.1.6'
-__version_tuple__ = version_tuple = (0, 1, 6)
+__version__ = version = '0.1.7'
+__version_tuple__ = version_tuple = (0, 1, 7)

napari_tmidas/napari.yaml

@@ -27,6 +27,12 @@ contributions:
     - id: napari-tmidas._file_conversion
       python_name: napari_tmidas._file_conversion:napari_experimental_provide_dock_widget
       title: Microscopy Image Converter
+    - id: napari-tmidas._crop_anything
+      python_name: napari_tmidas._crop_anything:batch_crop_anything_widget
+      title: Batch Crop Anything
+    - id: napari-tmidas._roi_colocalization
+      python_name: napari_tmidas._roi_colocalization:roi_colocalization_analyzer
+      title: Batch ROI Colocalization Analysis
   readers:
     - command: napari-tmidas.get_reader
       accepts_directories: false
@@ -49,3 +55,7 @@ contributions:
       display_name: Batch Label inspection
     - command: napari-tmidas._file_conversion
       display_name: Batch Microscopy Image Conversion
+    - command: napari-tmidas._crop_anything
+      display_name: Batch Crop Anything
+    - command: napari-tmidas._roi_colocalization
+      display_name: Batch ROI Colocalization Analysis

napari_tmidas/processing_functions/basic.py

@@ -40,3 +40,86 @@ def gamma_correction(image: np.ndarray, gamma: float = 1.0) -> np.ndarray:
 
     # Scale back to original range and dtype
     return (corrected * max_val).clip(0, max_val).astype(image.dtype)
+
+
+@BatchProcessingRegistry.register(
+    name="Max Z Projection",
+    suffix="_max_z",
+    description="Maximum intensity projection along the z-axis",
+    parameters={},
+)
+def max_z_projection(image: np.ndarray) -> np.ndarray:
+    """
+    Maximum intensity projection along the z-axis
+    """
+    # Determine maximum value based on dtype
+    max_val = (
+        np.iinfo(image.dtype).max
+        if np.issubdtype(image.dtype, np.integer)
+        else 1.0
+    )
+
+    # Normalize image to [0, 1]
+    normalized = image.astype(np.float32) / max_val
+
+    # Apply max z projection
+    projection = np.max(normalized, axis=0)
+
+    # Scale back to original range and dtype
+    return (projection * max_val).clip(0, max_val).astype(image.dtype)
+
+
+@BatchProcessingRegistry.register(
+    name="Split Channels",
+    suffix="_split_channels",
+    description="Splits the color channels of the image",
+    parameters={
+        "num_channels": {
+            "type": "integer",
+            "default": 3,
+            "description": "Number of color channels in the image",
+        }
+    },
+)
+def split_channels(image: np.ndarray, num_channels: int = 3) -> np.ndarray:
+    """
+    Split the image into separate channels based on the specified number of channels.
+
+    Args:
+        image: Input image array (at least 3D: XYC or higher dimensions)
+        num_channels: Number of channels in the image (default: 3)
+
+    Returns:
+        Stacked array of channels with shape (num_channels, ...)
+    """
+    # Validate input
+    if image.ndim < 3:
+        raise ValueError(
+            "Input must be an array with at least 3 dimensions (XYC or higher)"
+        )
+
+    print(f"Image shape: {image.shape}")
+    num_channels = int(num_channels)
+    # Identify the channel axis
+    possible_axes = [
+        axis
+        for axis, dim_size in enumerate(image.shape)
+        if dim_size == num_channels
+    ]
+    # print(f"Possible axes: {possible_axes}")
+    if len(possible_axes) != 1:
+
+        raise ValueError(
+            f"Could not uniquely identify a channel axis with {num_channels} channels. "
+            f"Found {len(possible_axes)} possible axes: {possible_axes}. "
+            f"Image shape: {image.shape}"
+        )
+
+    channel_axis = possible_axes[0]
+    print(f"Channel axis identified: {channel_axis}")
+
+    # Split and process channels
+    channels = np.split(image, num_channels, axis=channel_axis)
+    # channels = [np.squeeze(ch, axis=channel_axis) for ch in channels]
+
+    return np.stack(channels, axis=0)

napari_tmidas/processing_functions/colocalization.py

@@ -0,0 +1,242 @@
+"""
+ROI Colocalization Processing Function
+
+This module provides a function for batch processing to analyze colocalization
+between multiple labeled regions in image stacks.
+
+The function accepts a multi-channel input image with labeled regions and
+returns statistics about their colocalization.
+"""
+
+import numpy as np
+from skimage import measure
+
+from napari_tmidas._registry import BatchProcessingRegistry
+
+
+def get_nonzero_labels(image):
+    """Get unique, non-zero labels from an image."""
+    mask = image != 0
+    labels = np.unique(image[mask])
+    return [int(x) for x in labels]
+
+
+def count_unique_nonzero(array, mask):
+    """Count unique non-zero values in array where mask is True."""
+    unique_vals = np.unique(array[mask])
+    count = len(unique_vals)
+
+    # Remove 0 from count if present
+    if count > 0 and 0 in unique_vals:
+        count -= 1
+
+    return count
+
+
+def calculate_coloc_size(
+    image_c1, image_c2, label_id, mask_c2=None, image_c3=None
+):
+    """Calculate the size of colocalization between channels."""
+    # Create mask for current ROI
+    mask = image_c1 == int(label_id)
+
+    # Handle mask_c2 parameter
+    if mask_c2 is not None:
+        if mask_c2:
+            # sizes where c2 is present
+            mask = mask & (image_c2 != 0)
+            target_image = image_c3 if image_c3 is not None else image_c2
+        else:
+            # sizes where c2 is NOT present
+            mask = mask & (image_c2 == 0)
+            if image_c3 is None:
+                # If no image_c3, just return count of mask pixels
+                return np.count_nonzero(mask)
+            target_image = image_c3
+    else:
+        target_image = image_c2
+
+    # Calculate size of overlap
+    masked_image = target_image * mask
+    size = np.count_nonzero(masked_image)
+
+    return int(size)
+
+
+def process_single_roi(
+    label_id,
+    image_c1,
+    image_c2,
+    image_c3=None,
+    get_sizes=False,
+    roi_sizes=None,
+):
+    """Process a single ROI for colocalization analysis."""
+    # Create masks once
+    mask_roi = image_c1 == label_id
+    mask_c2 = image_c2 != 0
+
+    # Calculate counts
+    c2_in_c1_count = count_unique_nonzero(image_c2, mask_roi & mask_c2)
+
+    # Build the result dictionary
+    result = {"label_id": int(label_id), "ch2_in_ch1_count": c2_in_c1_count}
+
+    # Add size information if requested
+    if get_sizes:
+        if roi_sizes is None:
+            roi_sizes = {}
+            # Calculate sizes for current label only
+            area = np.sum(mask_roi)
+            roi_sizes[label_id] = area
+
+        size = roi_sizes.get(int(label_id), 0)
+        c2_in_c1_size = calculate_coloc_size(image_c1, image_c2, label_id)
+
+        result.update({"ch1_size": size, "ch2_in_ch1_size": c2_in_c1_size})
+
+    # Handle third channel if present
+    if image_c3 is not None:
+        mask_c3 = image_c3 != 0
+
+        # Calculate third channel statistics
+        c3_in_c2_in_c1_count = count_unique_nonzero(
+            image_c3, mask_roi & mask_c2 & mask_c3
+        )
+        c3_not_in_c2_but_in_c1_count = count_unique_nonzero(
+            image_c3, mask_roi & ~mask_c2 & mask_c3
+        )
+
+        result.update(
+            {
+                "ch3_in_ch2_in_ch1_count": c3_in_c2_in_c1_count,
+                "ch3_not_in_ch2_but_in_ch1_count": c3_not_in_c2_but_in_c1_count,
+            }
+        )
+
+        # Add size information for third channel if requested
+        if get_sizes:
+            c3_in_c2_in_c1_size = calculate_coloc_size(
+                image_c1, image_c2, label_id, mask_c2=True, image_c3=image_c3
+            )
+            c3_not_in_c2_but_in_c1_size = calculate_coloc_size(
+                image_c1, image_c2, label_id, mask_c2=False, image_c3=image_c3
+            )
+
+            result.update(
+                {
+                    "ch3_in_ch2_in_ch1_size": c3_in_c2_in_c1_size,
+                    "ch3_not_in_ch2_but_in_ch1_size": c3_not_in_c2_but_in_c1_size,
+                }
+            )
+
+    return result
+
+
+@BatchProcessingRegistry.register(
+    name="ROI Colocalization",
+    suffix="_coloc",
+    description="Analyze colocalization between ROIs in multiple channel label images",
+    parameters={
+        "get_sizes": {
+            "type": bool,
+            "default": False,
+            "description": "Calculate size statistics",
+        },
+        "size_method": {
+            "type": str,
+            "default": "median",
+            "description": "Method for size calculation (median or sum)",
+        },
+    },
+)
+def roi_colocalization(image, get_sizes=False, size_method="median"):
+    """
+    Calculate colocalization between channels for a multi-channel label image.
+
+    This function takes a multi-channel image where each channel contains
+    labeled objects (segmentation masks). It analyzes how objects in one channel
+    overlap with objects in the other channels, and returns detailed statistics
+    about their colocalization relationships.
+
+    Parameters:
+    -----------
+    image : numpy.ndarray
+        Input image array, should have shape corresponding to a multichannel
+        label image (e.g., [n_channels, height, width]).
+    get_sizes : bool, optional
+        Whether to calculate size statistics for overlapping regions.
+    size_method : str, optional
+        Method for calculating size statistics ('median' or 'sum').
+
+    Returns:
+    --------
+    numpy.ndarray
+        Multi-channel array with colocalization results
+    """
+    # Ensure image is a stack of label images (assume first dimension is channels)
+    if image.ndim < 3:
+        # Handle single channel image - not enough for colocalization
+        print("Input must have multiple channels for colocalization analysis")
+        # Return a copy of the input with markings
+        return image.copy()
+
+    # Extract channels
+    channels = [image[i] for i in range(min(3, image.shape[0]))]
+    n_channels = len(channels)
+
+    if n_channels < 2:
+        print("Need at least 2 channels for colocalization analysis")
+        return image.copy()
+
+    # Assign channels
+    image_c1, image_c2 = channels[:2]
+    image_c3 = channels[2] if n_channels > 2 else None
+
+    # Get unique label IDs in image_c1
+    label_ids = get_nonzero_labels(image_c1)
+
+    # Process each label
+    results = []
+    roi_sizes = {}
+
+    # Pre-calculate sizes for image_c1 if needed
+    if get_sizes:
+        for prop in measure.regionprops(image_c1.astype(np.uint32)):
+            label = int(prop.label)
+            roi_sizes[label] = int(prop.area)
+
+    for label_id in label_ids:
+        result = process_single_roi(
+            label_id, image_c1, image_c2, image_c3, get_sizes, roi_sizes
+        )
+        results.append(result)
+
+    # Create a new multi-channel output image with colocalization results
+    # Each channel will highlight different colocalization results
+    out_shape = image_c1.shape
+
+    # For 2 channels: [original ch1, ch2 overlap]
+    # For 3 channels: [original ch1, ch2 overlap, ch3 overlap]
+    output_channels = n_channels
+
+    # Create output array
+    output = np.zeros((output_channels,) + out_shape, dtype=np.uint32)
+
+    # Fill first channel with original labels
+    output[0] = image_c1
+
+    # Fill second channel with ch1 labels where ch2 overlaps
+    for label_id in label_ids:
+        mask = (image_c1 == label_id) & (image_c2 != 0)
+        if np.any(mask):
+            output[1][mask] = label_id
+
+    # Fill third channel with ch1 labels where ch3 overlaps (if applicable)
+    if image_c3 is not None and output_channels > 2:
+        for label_id in label_ids:
+            mask = (image_c1 == label_id) & (image_c3 != 0)
+            if np.any(mask):
+                output[2][mask] = label_id
+
+    return output

napari_tmidas/processing_functions/skimage_filters.py

@@ -20,38 +20,20 @@ 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
-    #     )
+    # 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(
@@ -63,6 +45,8 @@ if SKIMAGE_AVAILABLE:
         """
         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)
 
@@ -76,6 +60,7 @@ if SKIMAGE_AVAILABLE:
         """
         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)
 

{napari_tmidas-0.1.6.dist-info → napari_tmidas-0.1.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: napari-tmidas
-Version: 0.1.6
+Version: 0.1.7
 Summary: Tissue Microscopy Image Data Analysis Suite
 Author: Marco Meer
 Author-email: marco.meer@pm.me
@@ -75,11 +75,31 @@ 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) -->
-This Napari plugin allows you to perform batch image processing without a graphics processing unit (GPU). It will still be fast because computations will run in parallel on your central processing unit (CPU).
+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).
 
-This plugin provides you with a growing collection of pipelines for batch image preprocessing, segmentation, regions-of-interest (ROI) analysis and other useful features.
+## Feature Overview
+
+### Current Pipelines
+1. **Batch Image Processing**
+   - Process image folders with: Gamma correction, Z-projection, channel splitting, Gaussian/median filters, thresholding (Otsu/manual), and label cleaning
+
+2. **Batch Label Inspection**
+   - Review and edit label images with auto-save
+
+3. **Batch Microscopy Image Conversion**
+   - Convert .nd2/.lif/.ndpi/.czi/acquifer → .tif/.zarr with metadata preservation
+
+4. **Batch Crop Anything**
+   - Interactive ROI selection via click interface
+
+5. Batch ROI Colocalization
+   - Count colocalized labels across multiple channels
+
+
+
+### Coming Soon
+New features arriving April 2025
 
-`napari-tmidas` 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
 
@@ -98,29 +118,35 @@ To install the latest development version:
     pip install git+https://github.com/macromeer/napari-tmidas.git
 
 ### Dependencies
-For the File converter, we need some libraries to read some microscopy formats and to write ome-zarr:
+To use the Batch Microscopy Image Conversion pipeline, we need some libraries to read microscopy formats and to write ome-zarr:
+
+    pip install nd2 readlif tiffslide pylibCZIrw acquifer-napari ome-zarr napari-ome-zarr
 
-    pip install nd2 readlif tiffslide pylibCZIrw acquifer-napari ome-zarr
+For the Batch Crop Anything pipeline, we need to install MobileSAM and its dependencies:
 
+    pip install git+https://github.com/ChaoningZhang/MobileSAM.git
+    pip install torch torchvision timm opencv-python
 
 ## Usage
 
+To use the plugin, start napari in the activated virtual environment with this terminal command:
+
+    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)
 
 
-### File converter
+### Batch Microscopy Image Conversion
 
-You might first want to batch convert microscopy image data. Currently, this plugin supports `.nd2, .lif, .ndpi, .czi` and acquifer data. After launching the file converter, you can scan a folder of your choice for microscopy image data. It will also detect series images that you can preview. Start by selecting an original image in the first column of the table. This allows you to preview or convert.
+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)
 
+### Batch File Processing
 
-
-### File inspector
-
-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.
+1. After opening `Plugins > T-MIDAS > Batch Image Processing`, 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)
 
@@ -138,11 +164,15 @@ You might first want to batch convert microscopy image data. Currently, this plu
 
 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).
+### 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)
 
+### Batch 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`
+
+![image](https://github.com/user-attachments/assets/6d72c2a2-1064-4a27-b398-a9b86fcbc443)
 
 
 ## Contributing

napari_tmidas-0.1.7.dist-info/RECORD

@@ -0,0 +1,29 @@
+napari_tmidas/__init__.py,sha256=YNBLESwk8jr_TlDdkSC1CwH0tf0CKHF1i2_efzLjdpk,589
+napari_tmidas/_crop_anything.py,sha256=UxC0FbktgBPvxNMJtpXEATzIk0UFUO1DqRfrKy7bf30,39982
+napari_tmidas/_file_conversion.py,sha256=RnEOVavzApkeJfYb0_TmH6KWca0kpgxHZ517E65OQVI,71398
+napari_tmidas/_file_selector.py,sha256=8Plkoofa9nG5hSyOpQd6qjZlc8sFgBErnTwT5C24stg,34993
+napari_tmidas/_label_inspection.py,sha256=hCxKE0zYk-qBh4ohqiZcEGLXa-3lL8p88y45p2WnE1g,7329
+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=W_EoL8cAL4KhujvbYWEpb9NqRLbbrH0T024lJvRRWHI,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
+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=5v-_nRQK1Dssu8f3LFJIW73urmTEm3BX8lf9lrb9BBM,3690
+napari_tmidas/processing_functions/colocalization.py,sha256=O0-gJFVq62lfpOWNu0bJVYKZcsO6Z3HG6FsFkYho_j4,7684
+napari_tmidas/processing_functions/scipy_filters.py,sha256=kKpDAlQQ0ZNbkt77QUWi-Bwolk6MMDvtG_bZJV3MjOo,1612
+napari_tmidas/processing_functions/skimage_filters.py,sha256=kOwdYVUUqIYz9h-EBrYu0sFsmKkmqoTegkDoDywFwmE,3373
+napari_tmidas-0.1.7.dist-info/licenses/LICENSE,sha256=tSjiOqj57exmEIfP2YVPCEeQf0cH49S6HheQR8IiY3g,1485
+napari_tmidas-0.1.7.dist-info/METADATA,sha256=I9BacR_RRXFooM5PqbTaLb-zwf8OEfw9DJkM974s59I,10174
+napari_tmidas-0.1.7.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+napari_tmidas-0.1.7.dist-info/entry_points.txt,sha256=fbVjzbJTm4aDMIBtel1Lyqvq-CwXY7wmCOo_zJ-jtRY,60
+napari_tmidas-0.1.7.dist-info/top_level.txt,sha256=63ybdxCZ4SeT13f_Ou4TsivGV_2Gtm_pJOXToAt30_E,14
+napari_tmidas-0.1.7.dist-info/RECORD,,

napari_tmidas-0.1.6.dist-info/RECORD

@@ -1,26 +0,0 @@
-napari_tmidas/__init__.py,sha256=Z9mznblUlUsRyH3d4k8SxUo4iXLMwJXURbq41QzhPpo,459
-napari_tmidas/_file_conversion.py,sha256=Al59izNadYiqYmG-JT4TxXNifMt796x5yrvQbLc-8Eo,62547
-napari_tmidas/_file_selector.py,sha256=XLbqeQ4fG86gLHgmPZzrcmMTir5gpneO32KumJY8ZbM,27369
-napari_tmidas/_label_inspection.py,sha256=5p0heCX1xCQVYDGHe_R2gPwbZpl6sXIqLBwqbZLJKqo,6983
-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=ESbJO0YD7TYfOUv_WDIJJgWELGepEWsoyhqVifEcXPA,511
-napari_tmidas/_widget.py,sha256=u9uf9WILAwZg_InhFyjWInY4ej1TV1a59dR8Fe3vNF8,4794
-napari_tmidas/_writer.py,sha256=wbVfHFjjHdybSg37VR4lVmL-kdCkDZsUPDJ66AVLaFQ,1941
-napari_tmidas/napari.yaml,sha256=mY40xnwVygEjHpYGVVtGT2rkoUj-lNHsAg5y51yZbfE,2135
-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=m_Q1LwwmQ8Nto2eM7SbMw2o1wolbTr9ZqCnYzxEZy7I,1182
-napari_tmidas/processing_functions/scipy_filters.py,sha256=kKpDAlQQ0ZNbkt77QUWi-Bwolk6MMDvtG_bZJV3MjOo,1612
-napari_tmidas/processing_functions/skimage_filters.py,sha256=IsfMJTtd9Vwb47UlTEcLlXYv2CX6uTARV1CZCHY0HBw,4094
-napari_tmidas-0.1.6.dist-info/licenses/LICENSE,sha256=tSjiOqj57exmEIfP2YVPCEeQf0cH49S6HheQR8IiY3g,1485
-napari_tmidas-0.1.6.dist-info/METADATA,sha256=1SE1ALvJTwtYIBbDX0qRNFk028P3pn-38ElO2ZRDEEI,9114
-napari_tmidas-0.1.6.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-napari_tmidas-0.1.6.dist-info/entry_points.txt,sha256=fbVjzbJTm4aDMIBtel1Lyqvq-CwXY7wmCOo_zJ-jtRY,60
-napari_tmidas-0.1.6.dist-info/top_level.txt,sha256=63ybdxCZ4SeT13f_Ou4TsivGV_2Gtm_pJOXToAt30_E,14
-napari_tmidas-0.1.6.dist-info/RECORD,,