napari-tmidas 0.2.6__py3-none-any.whl → 0.3.1__py3-none-any.whl

napari_tmidas/_tests/test_intensity_label_filter.py

@@ -4,17 +4,15 @@
 import numpy as np
 import pytest
 
-# Try importing the functions - they may not be available if sklearn-extra is not installed
-try:
-    from napari_tmidas.processing_functions.intensity_label_filter import (
-        _calculate_label_mean_intensities,
-        _cluster_intensities,
-        _filter_labels_by_threshold,
-    )
-
-    HAS_KMEDOIDS = True
-except ImportError:
-    HAS_KMEDOIDS = False
+# Import the module and check if k-medoids is available
+from napari_tmidas.processing_functions.intensity_label_filter import (
+    _HAS_KMEDOIDS,
+    _calculate_label_mean_intensities,
+    _cluster_intensities,
+    _filter_labels_by_threshold,
+)
+
+HAS_KMEDOIDS = _HAS_KMEDOIDS
 
 
 @pytest.mark.skipif(

napari_tmidas/_tests/test_registry.py

@@ -1,11 +1,17 @@
 # src/napari_tmidas/_tests/test_registry.py
 from napari_tmidas._registry import BatchProcessingRegistry
+from napari_tmidas.processing_functions import discover_and_load_processing_functions
 
 
 class TestBatchProcessingRegistry:
     def setup_method(self):
         """Clear registry before each test"""
         BatchProcessingRegistry._processing_functions.clear()
+    
+    def teardown_method(self):
+        """Restore registry after each test"""
+        BatchProcessingRegistry._processing_functions.clear()
+        discover_and_load_processing_functions(reload=True)
 
     def test_register_function(self):
         """Test registering a processing function"""

napari_tmidas/_tests/test_viscy_virtual_staining.py

@@ -0,0 +1,138 @@
+# Test VisCy virtual staining integration
+"""
+Tests for VisCy virtual staining processing function.
+"""
+import numpy as np
+import pytest
+
+from napari_tmidas._registry import BatchProcessingRegistry
+from napari_tmidas.processing_functions import discover_and_load_processing_functions
+
+
+def test_viscy_registered():
+    """Test that VisCy function is registered."""
+    # Ensure processing functions are loaded
+    discover_and_load_processing_functions()
+    
+    functions = BatchProcessingRegistry.list_functions()
+    assert "VisCy Virtual Staining" in functions
+
+
+def test_viscy_function_info():
+    """Test that VisCy function has correct metadata."""
+    # Ensure processing functions are loaded
+    discover_and_load_processing_functions()
+    
+    info = BatchProcessingRegistry.get_function_info("VisCy Virtual Staining")
+    
+    assert info is not None
+    assert "description" in info
+    assert "parameters" in info
+    assert info["suffix"] == "_virtual_stain"
+    
+    # Check parameters
+    params = info["parameters"]
+    assert "dim_order" in params
+    assert "z_batch_size" in params
+    assert "output_channel" in params
+    
+    # Check parameter defaults
+    assert params["dim_order"]["default"] == "ZYX"
+    assert params["z_batch_size"]["default"] == 15
+    assert params["output_channel"]["default"] == "both"
+
+
+def test_viscy_import():
+    """Test that VisCy modules can be imported."""
+    from napari_tmidas.processing_functions import viscy_env_manager
+    from napari_tmidas.processing_functions import viscy_virtual_staining
+    
+    assert hasattr(viscy_env_manager, "ViscyEnvironmentManager")
+    assert hasattr(viscy_virtual_staining, "viscy_virtual_staining")
+
+
+def test_viscy_dimension_validation():
+    """Test that VisCy validates input dimensions."""
+    from napari_tmidas.processing_functions.viscy_virtual_staining import (
+        viscy_virtual_staining,
+    )
+    
+    # Test with 2D image (should fail)
+    image_2d = np.random.rand(512, 512)
+    with pytest.raises(ValueError, match="requires 3D images with Z dimension"):
+        viscy_virtual_staining(image_2d, dim_order="YX")
+    
+    # Test with insufficient Z slices (should fail)
+    image_3d_small = np.random.rand(10, 512, 512)  # Only 10 slices
+    with pytest.raises(ValueError, match="at least 15 Z slices"):
+        viscy_virtual_staining(image_3d_small, dim_order="ZYX")
+
+
+def test_viscy_transpose_dimensions():
+    """Test dimension transposition."""
+    from napari_tmidas.processing_functions.viscy_virtual_staining import (
+        transpose_dimensions,
+    )
+    
+    # Test ZYX (no change needed)
+    img = np.random.rand(15, 100, 100)
+    transposed, new_order, has_time = transpose_dimensions(img, "ZYX")
+    assert transposed.shape == (15, 100, 100)
+    assert new_order == "ZYX"
+    assert has_time is False
+    
+    # Test YXZ (should transpose)
+    img = np.random.rand(100, 100, 15)
+    transposed, new_order, has_time = transpose_dimensions(img, "YXZ")
+    assert transposed.shape == (15, 100, 100)
+    assert new_order == "ZYX"
+    assert has_time is False
+    
+    # Test TZYX (no change needed)
+    img = np.random.rand(5, 15, 100, 100)
+    transposed, new_order, has_time = transpose_dimensions(img, "TZYX")
+    assert transposed.shape == (5, 15, 100, 100)
+    assert new_order == "TZYX"
+    assert has_time is True
+
+
+def test_viscy_env_manager():
+    """Test VisCy environment manager."""
+    from napari_tmidas.processing_functions.viscy_env_manager import (
+        ViscyEnvironmentManager,
+    )
+    
+    manager = ViscyEnvironmentManager()
+    assert manager.env_name == "viscy"
+    assert "viscy" in manager.env_dir
+    assert "models" in manager.model_dir
+
+
+def test_viscy_output_channel_options():
+    """Test that output channel options are correctly defined."""
+    # Ensure processing functions are loaded
+    discover_and_load_processing_functions()
+    
+    info = BatchProcessingRegistry.get_function_info("VisCy Virtual Staining")
+    params = info["parameters"]
+    
+    assert "output_channel" in params
+    assert "options" in params["output_channel"]
+    
+    options = params["output_channel"]["options"]
+    assert "both" in options
+    assert "nuclei" in options
+    assert "membrane" in options
+
+
+if __name__ == "__main__":
+    # Run basic tests
+    test_viscy_registered()
+    test_viscy_function_info()
+    test_viscy_import()
+    test_viscy_dimension_validation()
+    test_viscy_transpose_dimensions()
+    test_viscy_env_manager()
+    test_viscy_output_channel_options()
+    
+    print("✓ All tests passed!")

napari_tmidas/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.2.6'
-__version_tuple__ = version_tuple = (0, 2, 6)
+__version__ = version = '0.3.1'
+__version_tuple__ = version_tuple = (0, 3, 1)
 
 __commit_id__ = commit_id = None

napari_tmidas/processing_functions/__init__.py

@@ -5,16 +5,20 @@ Package for processing functions that can be registered with the batch processin
 import importlib
 import os
 import pkgutil
+import sys
 from typing import Dict, List
 
 # Keep the registry global
 from napari_tmidas._registry import BatchProcessingRegistry
 
 
-def discover_and_load_processing_functions() -> List[str]:
+def discover_and_load_processing_functions(reload: bool = False) -> List[str]:
     """
     Discover and load all processing functions from the processing_functions package.
 
+    Args:
+        reload: If True, force reload of modules even if already imported
+
     Returns:
         List of registered function names
     """
@@ -27,12 +31,27 @@ def discover_and_load_processing_functions() -> List[str]:
     ):
         if not is_pkg:  # Only load non-package modules
             try:
-                # Import the module
-                importlib.import_module(f"{package}.{module_name}")
+                module_fullname = f"{package}.{module_name}"
+                
+                # If reload requested and module already loaded, reload it
+                if reload and module_fullname in sys.modules:
+                    importlib.reload(sys.modules[module_fullname])
+                else:
+                    # Import the module
+                    importlib.import_module(module_fullname)
+                
                 print(f"Loaded processing function module: {module_name}")
-            except ImportError as e:
+            except (ImportError, ValueError) as e:
                 # Log the error but continue with other modules
-                print(f"Failed to import {module_name}: {e}")
+                # ValueError catches NumPy binary incompatibility issues
+                error_msg = str(e)
+                if "numpy.dtype size changed" in error_msg:
+                    print(
+                        f"Failed to import {module_name}: NumPy binary incompatibility. "
+                        "Try: pip install --force-reinstall --no-cache-dir scikit-learn-extra"
+                    )
+                else:
+                    print(f"Failed to import {module_name}: {e}")
 
     # Return the list of registered functions
     return BatchProcessingRegistry.list_functions()

napari_tmidas/processing_functions/cellpose_env_manager.py

@@ -67,6 +67,28 @@ class CellposeEnvironmentManager(BaseEnvironmentManager):
             "Installing Cellpose 4 (Cellpose-SAM) in the dedicated environment..."
         )
 
+        # First, install PyTorch with CUDA 12.x support for sm_120 compatibility
+        # RTX PRO 4000 Blackwell has CUDA capability sm_120, which requires newer PyTorch
+        print("Installing PyTorch with CUDA 12.x support (for sm_120 compatibility)...")
+        try:
+            subprocess.check_call(
+                [
+                    env_python,
+                    "-m",
+                    "pip",
+                    "install",
+                    "torch",
+                    "torchvision",
+                    "torchaudio",
+                    "--index-url",
+                    "https://download.pytorch.org/whl/cu124",
+                ]
+            )
+            print("✓ PyTorch with CUDA 12.4 installed successfully")
+        except subprocess.CalledProcessError as e:
+            print(f"✗ Failed to install PyTorch: {e}")
+            raise
+
         # Install packages one by one with error checking
         packages = ["cellpose", "zarr", "tifffile"]
         for package in packages:

napari_tmidas/processing_functions/intensity_label_filter.py

@@ -47,12 +47,23 @@ try:
     from sklearn_extra.cluster import KMedoids
 
     _HAS_KMEDOIDS = True
-except ImportError:
+except (ImportError, ValueError) as e:
+    # ImportError: package not installed
+    # ValueError: binary incompatibility (e.g., numpy version mismatch)
     KMedoids = None
     _HAS_KMEDOIDS = False
-    print(
-        "scikit-learn-extra not available. Install with: pip install scikit-learn-extra"
-    )
+    error_msg = str(e)
+    if "numpy.dtype size changed" in error_msg:
+        print(
+            "scikit-learn-extra has a NumPy binary incompatibility. "
+            "This is typically resolved by reinstalling scikit-learn-extra. "
+            "Run: pip install --force-reinstall --no-cache-dir scikit-learn-extra"
+        )
+    else:
+        print(
+            f"scikit-learn-extra not available ({type(e).__name__}). "
+            "Install with: pip install scikit-learn-extra"
+        )
 
 try:
     import pandas as pd

napari_tmidas/processing_functions/skimage_filters.py

@@ -2,6 +2,9 @@
 """
 Processing functions that depend on scikit-image.
 """
+import concurrent.futures
+import os
+
 import numpy as np
 
 try:
@@ -61,7 +64,7 @@ if SKIMAGE_AVAILABLE:
         Parameters
         ----------
         image : np.ndarray
-            Input image
+            Input image (supports 2D, 3D, and 4D arrays like YX, ZYX, TYX, TZYX)
         clip_limit : float
             Clipping limit for contrast limiting (normalized to 0-1 range, e.g., 0.01 = 1%)
             Higher values give more contrast but may amplify noise
@@ -72,9 +75,18 @@ if SKIMAGE_AVAILABLE:
         -------
         np.ndarray
             CLAHE-enhanced image with same dtype as input
+        
+        Notes
+        -----
+        For large multi-dimensional datasets (TZYX), processing is parallelized across
+        the first dimension to utilize multiple CPU cores effectively.
         """
         # Store original dtype to convert back later
         original_dtype = image.dtype
+        
+        # Print diagnostic info for multi-dimensional data
+        if image.ndim > 2:
+            print(f"Applying CLAHE to {image.ndim}D image with shape {image.shape}")
 
         # Auto-calculate kernel size if not specified
         if kernel_size <= 0:
@@ -87,13 +99,64 @@ if SKIMAGE_AVAILABLE:
         # Ensure kernel_size is odd
         if kernel_size % 2 == 0:
             kernel_size += 1
-
-        # Apply CLAHE using scikit-image's equalize_adapthist
-        # Note: clip_limit in equalize_adapthist is already normalized (0-1 range)
-        # This returns float64 in range [0, 1]
-        result = skimage.exposure.equalize_adapthist(
-            image, kernel_size=kernel_size, clip_limit=clip_limit
-        )
+        
+        if image.ndim > 2:
+            print(f"Using kernel_size={kernel_size}, clip_limit={clip_limit}")
+        
+        # For 4D data (TZYX), parallelize across first dimension for better performance
+        if image.ndim == 4 and image.shape[0] > 1:
+            print(f"Parallelizing CLAHE across {image.shape[0]} timepoints/slices using {max(1, os.cpu_count() - 1)} workers...")
+            
+            def process_slice(idx):
+                """Process a single slice along first dimension"""
+                result_slice = skimage.exposure.equalize_adapthist(
+                    image[idx], kernel_size=kernel_size, clip_limit=clip_limit
+                )
+                if (idx + 1) % max(1, image.shape[0] // 10) == 0:
+                    print(f"  Processed {idx + 1}/{image.shape[0]} slices")
+                return result_slice
+            
+            # Process in parallel
+            with concurrent.futures.ThreadPoolExecutor(
+                max_workers=max(1, os.cpu_count() - 1)
+            ) as executor:
+                futures = [executor.submit(process_slice, i) for i in range(image.shape[0])]
+                results = [future.result() for future in futures]
+            
+            result = np.stack(results, axis=0)
+            print("CLAHE processing complete!")
+            
+        elif image.ndim == 3 and image.shape[0] > 5:
+            # For 3D data with many slices, also parallelize
+            print(f"Parallelizing CLAHE across {image.shape[0]} slices using {max(1, os.cpu_count() - 1)} workers...")
+            
+            def process_slice(idx):
+                """Process a single 2D slice"""
+                result_slice = skimage.exposure.equalize_adapthist(
+                    image[idx], kernel_size=kernel_size, clip_limit=clip_limit
+                )
+                if (idx + 1) % max(1, image.shape[0] // 10) == 0:
+                    print(f"  Processed {idx + 1}/{image.shape[0]} slices")
+                return result_slice
+            
+            # Process in parallel
+            with concurrent.futures.ThreadPoolExecutor(
+                max_workers=max(1, os.cpu_count() - 1)
+            ) as executor:
+                futures = [executor.submit(process_slice, i) for i in range(image.shape[0])]
+                results = [future.result() for future in futures]
+            
+            result = np.stack(results, axis=0)
+            print("CLAHE processing complete!")
+        else:
+            # For 2D or small 3D data, use native implementation
+            if image.ndim > 2:
+                print("Processing...")
+            result = skimage.exposure.equalize_adapthist(
+                image, kernel_size=kernel_size, clip_limit=clip_limit
+            )
+            if image.ndim > 2:
+                print("CLAHE processing complete!")
 
         # Convert back to original dtype to preserve compatibility
         if np.issubdtype(original_dtype, np.integer):