napari-tmidas 0.2.1__py3-none-any.whl → 0.2.2__py3-none-any.whl

napari_tmidas/_crop_anything.py

@@ -8,11 +8,8 @@ The plugin supports both 2D (YX) and 3D (TYX/ZYX) data.
 
 import contextlib
 import os
-
-# Add this at the beginning of your plugin file
 import sys
 
-sys.path.append("/opt/sam2")
 import numpy as np
 import requests
 import torch
@@ -40,10 +37,30 @@ from tifffile import imwrite
 
 from napari_tmidas.processing_functions.sam2_mp4 import tif_to_mp4
 
+sam2_paths = [
+    os.environ.get("SAM2_PATH"),
+    "/opt/sam2",
+    os.path.expanduser("~/sam2"),
+    "./sam2",
+]
+
+for path in sam2_paths:
+    if path and os.path.exists(path):
+        sys.path.append(path)
+        break
+else:
+    print(
+        "Warning: SAM2 not found in common locations. Please set SAM2_PATH environment variable."
+    )
+
+
 def get_device():
     if sys.platform == "darwin":
         # MacOS: Only check for MPS
-        if hasattr(torch.backends, "mps") and torch.backends.mps.is_available():
+        if (
+            hasattr(torch.backends, "mps")
+            and torch.backends.mps.is_available()
+        ):
             device = torch.device("mps")
             print("Using Apple Silicon GPU (MPS)")
         else:
@@ -60,8 +77,6 @@ def get_device():
     return device
 
 
-
-
 class BatchCropAnything:
     """Class for processing images with SAM2 and cropping selected objects."""
 
@@ -104,7 +119,7 @@ class BatchCropAnything:
             filename = os.path.join(dest_folder, url.split("/")[-1])
             if not os.path.exists(filename):
                 print(f"Downloading checkpoint to {filename}...")
-                response = requests.get(url, stream=True)
+                response = requests.get(url, stream=True, timeout=30)
                 response.raise_for_status()
                 with open(filename, "wb") as f:
                     for chunk in response.iter_content(chunk_size=8192):
@@ -733,6 +748,15 @@ class BatchCropAnything:
                     border_width=1,
                     opacity=0.8,
                 )
+
+                with contextlib.suppress(AttributeError, ValueError):
+                    points_layer.mouse_drag_callbacks.remove(
+                        self._on_points_clicked
+                    )
+                    points_layer.mouse_drag_callbacks.append(
+                        self._on_points_clicked
+                    )
+
                 # Initialize points for this object
                 if not hasattr(self, "sam2_points_by_obj"):
                     self.sam2_points_by_obj = {}
@@ -1107,6 +1131,14 @@ class BatchCropAnything:
                 opacity=0.8,
             )
 
+            with contextlib.suppress(AttributeError, ValueError):
+                points_layer.mouse_drag_callbacks.remove(
+                    self._on_points_clicked
+                )
+                points_layer.mouse_drag_callbacks.append(
+                    self._on_points_clicked
+                )
+
             # Connect points layer mouse click event
             points_layer.mouse_drag_callbacks.append(self._on_points_clicked)
 
@@ -1646,6 +1678,14 @@ class BatchCropAnything:
                             border_width=1,
                             opacity=0.8,
                         )
+                        with contextlib.suppress(AttributeError, ValueError):
+                            points_layer.mouse_drag_callbacks.remove(
+                                self._on_points_clicked
+                            )
+                            points_layer.mouse_drag_callbacks.append(
+                                self._on_points_clicked
+                            )
+
                         self.obj_points[current_obj_id] = [[x, y]]
                         self.obj_labels[current_obj_id] = [point_label]
                     else:
@@ -1923,6 +1963,14 @@ class BatchCropAnything:
             opacity=0.8,
         )
 
+        with contextlib.suppress(AttributeError, ValueError):
+            self.points_layer.mouse_drag_callbacks.remove(
+                self._on_points_clicked
+            )
+            self.points_layer.mouse_drag_callbacks.append(
+                self._on_points_clicked
+            )
+
     def create_label_table(self, parent_widget):
         """Create a table widget displaying all detected labels."""
         # Create table widget

napari_tmidas/_file_selector.py

@@ -558,6 +558,10 @@ class ProcessingWorker(QThread):
         self.stop_requested = False
         self.thread_count = max(1, (os.cpu_count() or 4) - 1)  # Default value
 
+    def stop(self):
+        """Request the worker to stop processing"""
+        self.stop_requested = True
+
     def run(self):
         """Process files in a separate thread"""
         # Track processed files
@@ -653,9 +657,12 @@ class ProcessingWorker(QThread):
             # Generate new filename base
             filename = os.path.basename(filepath)
             name, ext = os.path.splitext(filename)
-            new_filename_base = (
-                name.replace(self.input_suffix, "") + self.output_suffix
-            )
+            if name.endswith(self.input_suffix):
+                new_filename_base = (
+                    name[: -len(self.input_suffix)] + self.output_suffix
+                )
+            else:
+                new_filename_base = name + self.output_suffix
 
             # Check if the first dimension should be treated as channels
             # If processed_image has more dimensions than the original image,
@@ -779,13 +786,8 @@ class ProcessingWorker(QThread):
                     "labels" in new_filename_base
                     or "semantic" in new_filename_base
                 ):
-                    # Choose appropriate integer type based on data range
-                    if data_max <= 255:
-                        save_dtype = np.uint8
-                    elif data_max <= 65535:
-                        save_dtype = np.uint16
-                    else:
-                        save_dtype = np.uint32
+
+                    save_dtype = np.uint32
 
                     print(
                         f"Saving label image as {save_dtype.__name__} with bigtiff={use_bigtiff}"

napari_tmidas/_registry.py

@@ -2,6 +2,7 @@
 """
 Registry for batch processing functions.
 """
+import threading
 from typing import Any, Dict, List, Optional
 
 
@@ -11,6 +12,7 @@ class BatchProcessingRegistry:
     """
 
     _processing_functions = {}
+    _lock = threading.RLock()  # Add thread lock
 
     @classmethod
     def register(
@@ -43,26 +45,25 @@ class BatchProcessingRegistry:
             parameters = {}
 
         def decorator(func):
-            cls._processing_functions[name] = {
-                "func": func,
-                "suffix": suffix,
-                "description": description,
-                "parameters": parameters,
-            }
+            with cls._lock:  # Thread-safe registration
+                cls._processing_functions[name] = {
+                    "func": func,
+                    "suffix": suffix,
+                    "description": description,
+                    "parameters": parameters,
+                }
             return func
 
         return decorator
 
     @classmethod
     def get_function_info(cls, name: str) -> Optional[dict]:
-        """
-        Retrieve a registered processing function and its metadata
-        """
-        return cls._processing_functions.get(name)
+        """Thread-safe retrieval"""
+        with cls._lock:
+            return cls._processing_functions.get(name)
 
     @classmethod
     def list_functions(cls) -> List[str]:
-        """
-        List all registered processing function names
-        """
-        return list(cls._processing_functions.keys())
+        """Thread-safe listing"""
+        with cls._lock:
+            return list(cls._processing_functions.keys())

napari_tmidas/_tests/test_file_selector.py

@@ -0,0 +1,90 @@
+# src/napari_tmidas/_tests/test_file_selector.py
+import os
+import tempfile
+from unittest.mock import Mock
+
+import numpy as np
+
+from napari_tmidas._file_selector import ProcessingWorker, file_selector
+from napari_tmidas._registry import BatchProcessingRegistry
+
+
+class TestProcessingWorker:
+    def setup_method(self):
+        """Setup test environment"""
+        self.temp_dir = tempfile.mkdtemp()
+        BatchProcessingRegistry._processing_functions.clear()
+
+        # Register a test function
+        @BatchProcessingRegistry.register(name="Test Process", suffix="_proc")
+        def test_process(image):
+            return image * 2
+
+        self.test_func = BatchProcessingRegistry.get_function_info(
+            "Test Process"
+        )["func"]
+
+    def teardown_method(self):
+        """Cleanup"""
+        import shutil
+
+        shutil.rmtree(self.temp_dir)
+
+    def test_process_file(self):
+        """Test processing a single file"""
+        # Create test image
+        test_image = np.random.rand(100, 100)
+        input_path = os.path.join(self.temp_dir, "test.tif")
+
+        import tifffile
+
+        tifffile.imwrite(input_path, test_image)
+
+        # Create worker
+        worker = ProcessingWorker(
+            [input_path], self.test_func, {}, self.temp_dir, "", "_proc"
+        )
+
+        # Process file
+        result = worker.process_file(input_path)
+
+        assert result is not None
+        assert "original_file" in result
+        assert "processed_file" in result
+        assert os.path.exists(result["processed_file"])
+
+    def test_multi_channel_output(self):
+        """Test processing that outputs multiple channels"""
+
+        @BatchProcessingRegistry.register(
+            name="Split Channels", suffix="_split"
+        )
+        def split_channels(image):
+            return np.stack([image, image * 2, image * 3])
+
+        test_image = np.random.rand(100, 100)
+        input_path = os.path.join(self.temp_dir, "test.tif")
+
+        import tifffile
+
+        tifffile.imwrite(input_path, test_image)
+
+        func_info = BatchProcessingRegistry.get_function_info("Split Channels")
+        worker = ProcessingWorker(
+            [input_path], func_info["func"], {}, self.temp_dir, "", "_split"
+        )
+
+        result = worker.process_file(input_path)
+
+        assert "processed_files" in result
+        assert len(result["processed_files"]) == 3
+
+
+class TestFileSelector:
+    def test_file_selector_widget_creation(self):
+        """Test that file selector widget is created properly"""
+        viewer_mock = Mock()
+
+        # Test the widget can be called
+        result = file_selector(viewer_mock, "/tmp", ".tif")
+        assert isinstance(result, list)

napari_tmidas/_tests/test_registry.py

@@ -0,0 +1,67 @@
+# src/napari_tmidas/_tests/test_registry.py
+from napari_tmidas._registry import BatchProcessingRegistry
+
+
+class TestBatchProcessingRegistry:
+    def setup_method(self):
+        """Clear registry before each test"""
+        BatchProcessingRegistry._processing_functions.clear()
+
+    def test_register_function(self):
+        """Test registering a processing function"""
+
+        @BatchProcessingRegistry.register(
+            name="Test Function",
+            suffix="_test",
+            description="Test description",
+            parameters={"param1": {"type": int, "default": 5}},
+        )
+        def test_func(image, param1=5):
+            return image + param1
+
+        assert "Test Function" in BatchProcessingRegistry.list_functions()
+        info = BatchProcessingRegistry.get_function_info("Test Function")
+        assert info["suffix"] == "_test"
+        assert info["description"] == "Test description"
+        assert info["func"] == test_func
+
+    def test_list_functions(self):
+        """Test listing registered functions"""
+
+        @BatchProcessingRegistry.register(name="Func1")
+        def func1(image):
+            return image
+
+        @BatchProcessingRegistry.register(name="Func2")
+        def func2(image):
+            return image
+
+        functions = BatchProcessingRegistry.list_functions()
+        assert len(functions) == 2
+        assert "Func1" in functions
+        assert "Func2" in functions
+
+    def test_thread_safety(self):
+        """Test thread-safe registration"""
+        import threading
+
+        results = []
+
+        def register_func(i):
+            @BatchProcessingRegistry.register(name=f"ThreadFunc{i}")
+            def func(image):
+                return image
+
+            results.append(i)
+
+        threads = [
+            threading.Thread(target=register_func, args=(i,))
+            for i in range(10)
+        ]
+        for t in threads:
+            t.start()
+        for t in threads:
+            t.join()
+
+        assert len(results) == 10
+        assert len(BatchProcessingRegistry.list_functions()) == 10

napari_tmidas/_version.py

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

napari_tmidas/processing_functions/trackastra_tracking.py

@@ -252,16 +252,35 @@ def trackastra_tracking(
 
     temp_dir = Path(os.path.dirname(img_path))
 
-    # Save the mask data
-    mask_path = img_path.replace(".tif", "_labels.tif")
     # Create the tracking script
     script_path = temp_dir / "run_tracking.py"
-    output_path = temp_dir / os.path.basename(img_path).replace(
-        ".tif", "_tracked.tif"
+    # Save the mask data
+    # For label images, use the original path as mask_path
+    if label_pattern in os.path.basename(img_path):
+        mask_path = img_path
+        # Find corresponding raw image by removing the label pattern
+        raw_base = os.path.basename(img_path).replace(label_pattern, "")
+        raw_path = os.path.join(os.path.dirname(img_path), raw_base + ".tif")
+        if not os.path.exists(raw_path):
+            print(f"Warning: Could not find raw image for {img_path}")
+            raw_path = img_path  # Fallback to using label as input
+    else:
+        # For raw images, find the corresponding label image
+        raw_path = img_path
+        base_name = os.path.basename(img_path).replace(".tif", "")
+        mask_path = os.path.join(
+            os.path.dirname(img_path), base_name + label_pattern
+        )
+        if not os.path.exists(mask_path):
+            print(f"No label file found for {img_path}")
+            return image
+
+    output_path = temp_dir / os.path.basename(mask_path).replace(
+        label_pattern, "_tracked.tif"
     )
 
     script_content = create_trackastra_script(
-        str(img_path), str(mask_path), model, mode, str(output_path)
+        str(raw_path), str(mask_path), model, mode, str(output_path)
     )
 
     with open(script_path, "w") as f:

{napari_tmidas-0.2.1.dist-info → napari_tmidas-0.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: napari-tmidas
-Version: 0.2.1
+Version: 0.2.2
 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
@@ -48,13 +48,13 @@ Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Scientific/Engineering :: Image Processing
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy
 Requires-Dist: magicgui
+Requires-Dist: tqdm
 Requires-Dist: qtpy
 Requires-Dist: scikit-image
 Requires-Dist: pyqt5
@@ -66,6 +66,14 @@ Requires-Dist: torch
 Requires-Dist: torchvision
 Requires-Dist: timm
 Requires-Dist: opencv-python
+Requires-Dist: cmake
+Requires-Dist: nd2
+Requires-Dist: pylibCZIrw
+Requires-Dist: readlif
+Requires-Dist: tiffslide
+Requires-Dist: hydra-core
+Requires-Dist: eva-decord
+Requires-Dist: acquifer-napari
 Provides-Extra: testing
 Requires-Dist: tox; extra == "testing"
 Requires-Dist: pytest; extra == "testing"
@@ -90,9 +98,11 @@ Currently, napari-tmidas provides pipelines as widgets for batch image conversio
 
 ## Installation
 
+(Video installation guides: https://www.youtube.com/@macromeer/videos)
+
 First, install Napari in a virtual environment:
 
-    mamba create -y -n napari-tmidas -c conda-forge python=3.11 tqdm
+    mamba create -y -n napari-tmidas -c conda-forge python=3.11
     mamba activate napari-tmidas
     python -m pip install "napari[all]"
 
@@ -100,34 +110,28 @@ Now you can install `napari-tmidas` via [pip]:
 
     pip install napari-tmidas
 
-It is recommended to install the latest development version. Please also regularly execute this command in the activated environment:
+It is recommended though to install the **latest development version**. Please also execute this command from time to time in the activated environment to benefit from newly added features:
 
     pip install git+https://github.com/macromeer/napari-tmidas.git
 
-### Dependencies
-
-To use the Batch Microscopy Image Conversion pipeline, we need some libraries to read microscopy formats:
-
-    # mamba activate napari-tmidas
-    pip install nd2 readlif tiffslide pylibCZIrw acquifer-napari
+To use the Batch Crop Anything pipeline, we need to install **Segment Anything 2** (2D/3D):
 
-If you want to batch compress images using [Zstandard](https://github.com/facebook/zstd), use the package manager of your operating system to install it:
+    cd /opt # if the folder does not exist: mkdir /opt && cd /opt
+    git clone https://github.com/facebookresearch/sam2.git && cd sam2
+    pip install -e .
+    curl -L https://dl.fbaipublicfiles.com/segment_anything_2/092824/sam2.1_hiera_large.pt -o checkpoints/sam2.1_hiera_large.pt
+    mamba install -c conda-forge ffmpeg # we also need ffmpeg
 
-    sudo apt-get install zstd    # for Linux
-    brew install zstd            # for macOS
-    choco install zstandard      # for Windows
+If you want to batch compress image data using [Zstandard](https://github.com/facebook/zstd), use the package manager of your operating system to install it:
 
-To use the Batch Crop Anything pipeline, we need to install SAM2 in the napari-tmidas environment:
+   ~~sudo apt-get install zstd~~    # Pre-installed on Linux :man_shrugging:
 
-    # mamba activate napari-tmidas
-    cd /opt
-    git clone https://github.com/facebookresearch/sam2.git && cd sam2
-    pip install -e .
-    wget https://dl.fbaipublicfiles.com/segment_anything_2/092824/sam2.1_hiera_large.pt -P checkpoints/
-    pip install decord
+    brew install zstd            # for macOS (requires [Homebrew](https://brew.sh/)
+    pip install zstandard        # Windows with Python >= 3.7
 
 
 
+And you are done! 
 
 ## Usage
 
@@ -166,18 +170,27 @@ You can start this pipeline via `Plugins > T-MIDAS > Batch Microscopy Image Conv
 
 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.
 
+
+#### Processing Function Credits
+
+The image processing capabilities are powered by several excellent open-source tools:
+- [Cellpose 4](https://github.com/MouseLand/cellpose): Advanced cell segmentation
+- [Trackastra](https://github.com/weigertlab/trackastra): Cell tracking and analysis
+- [CAREamics](https://github.com/CAREamics/careamics): Content-aware image restoration and enhancement
+
 ### 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).
 
 <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.
+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`. Cropping works like this: Enter 2D view and go to the first z slice where the object to be cropped is appearing. Activate/select the points layer and click on the object. Terminal shows progress. You can then proceed to select another object (always do this in 2D mode)
 
 <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-0.2.1.dist-info → napari_tmidas-0.2.2.dist-info}/RECORD

@@ -1,18 +1,20 @@
 napari_tmidas/__init__.py,sha256=YNBLESwk8jr_TlDdkSC1CwH0tf0CKHF1i2_efzLjdpk,589
-napari_tmidas/_crop_anything.py,sha256=KgGZhNEHaGbk6npDHXGi7FrgahsfivlVwvdNAAYdME0,101452
+napari_tmidas/_crop_anything.py,sha256=2UMUddQ6mdX96FiJPKpQnG1P1atFrxlz41JYWM3933k,103088
 napari_tmidas/_file_conversion.py,sha256=V6evJmggUwOFzJO203Y5ltboHXEWNJQckZPedGRkrLI,72203
-napari_tmidas/_file_selector.py,sha256=JQ8t_nVzJXqlVUwIBjGE2jJDeyhuDKCXHJP_cPbzzBw,43091
+napari_tmidas/_file_selector.py,sha256=tuWxfmHuvILp70cGl6bsEyhRxKNum45GKD6-st-1hnM,43056
 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/_registry.py,sha256=fxBPLFCvXtjSHfcVIRb6KI9DkqIWRUpPPg_3pD8sXns,2110
 napari_tmidas/_roi_colocalization.py,sha256=OVjdHvtFN07DgrtTX8uqbrxZL6jVwl2L3klorgW2C9k,43196
 napari_tmidas/_sample_data.py,sha256=khuv1jemz_fCjqNwEKMFf83Ju0EN4S89IKydsUMmUxw,645
-napari_tmidas/_version.py,sha256=UoNvMtd4wCG76RwoSpNCUtaFyTwakGcZolfjXzNVSMY,511
+napari_tmidas/_version.py,sha256=OjGGK5TcHVG44Y62aAqeJH4CskkZoY9ydbHOtCDew50,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_file_selector.py,sha256=Sbu0BCXTaQAeUJLtOVjIC87AUARbi8J0bXBlMJe53ew,2687
 napari_tmidas/_tests/test_reader.py,sha256=gN_2StATLZYUL56X27ImJTVru_qSoFiY4vtgajcx3H0,975
+napari_tmidas/_tests/test_registry.py,sha256=DSI6NdmuIS1sYAa3LrVge0rOS5Ycb3TXFXxol3vDyRA,2061
 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
@@ -29,10 +31,10 @@ napari_tmidas/processing_functions/sam2_mp4.py,sha256=NF0dWar2uyP_yQWxC8e08J6198
 napari_tmidas/processing_functions/scipy_filters.py,sha256=kKpDAlQQ0ZNbkt77QUWi-Bwolk6MMDvtG_bZJV3MjOo,1612
 napari_tmidas/processing_functions/skimage_filters.py,sha256=tSBx0nal88ixxVbu5o7ojTn90HgsUTt-aA_T6XLvmyY,16320
 napari_tmidas/processing_functions/timepoint_merger.py,sha256=DwL5vZBSplXt9dBBrKtMm9aH_NvT3mY7cdbeGg2OU_Y,16567
-napari_tmidas/processing_functions/trackastra_tracking.py,sha256=4kswVZCRHJ68oY95ezZmSrXMNrhjjEeN5x8a7GIjh4E,9084
-napari_tmidas-0.2.1.dist-info/licenses/LICENSE,sha256=tSjiOqj57exmEIfP2YVPCEeQf0cH49S6HheQR8IiY3g,1485
-napari_tmidas-0.2.1.dist-info/METADATA,sha256=AYL6vxMkpxPlXBrYZdBOvH1_AuNAQ83X68hue3KfA_k,11874
-napari_tmidas-0.2.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-napari_tmidas-0.2.1.dist-info/entry_points.txt,sha256=fbVjzbJTm4aDMIBtel1Lyqvq-CwXY7wmCOo_zJ-jtRY,60
-napari_tmidas-0.2.1.dist-info/top_level.txt,sha256=63ybdxCZ4SeT13f_Ou4TsivGV_2Gtm_pJOXToAt30_E,14
-napari_tmidas-0.2.1.dist-info/RECORD,,
+napari_tmidas/processing_functions/trackastra_tracking.py,sha256=IkFk5HoEZmKdcu5jXri4WMhHN1KTADDMxSpeYfPgSbo,9976
+napari_tmidas-0.2.2.dist-info/licenses/LICENSE,sha256=tSjiOqj57exmEIfP2YVPCEeQf0cH49S6HheQR8IiY3g,1485
+napari_tmidas-0.2.2.dist-info/METADATA,sha256=cY8vgH2bnjC9elLZ0uxIBVJeTckVbg7UxnV2L5u4wTc,12742
+napari_tmidas-0.2.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+napari_tmidas-0.2.2.dist-info/entry_points.txt,sha256=fbVjzbJTm4aDMIBtel1Lyqvq-CwXY7wmCOo_zJ-jtRY,60
+napari_tmidas-0.2.2.dist-info/top_level.txt,sha256=63ybdxCZ4SeT13f_Ou4TsivGV_2Gtm_pJOXToAt30_E,14
+napari_tmidas-0.2.2.dist-info/RECORD,,