senoquant 1.0.0b2__py3-none-any.whl → 1.0.0b3__py3-none-any.whl

senoquant/tabs/segmentation/models/default_3d/model.py

@@ -19,6 +19,9 @@ from senoquant.tabs.segmentation.stardist_onnx_utils.onnx_framework import (
     normalize,
     predict_tiled,
 )
+from senoquant.tabs.segmentation.stardist_onnx_utils.onnx_framework.stardist_libs import (
+    ensure_stardist_libs,
+)
 from senoquant.tabs.segmentation.stardist_onnx_utils.onnx_framework.inspect import (
     make_probe_image,
 )
@@ -240,7 +243,7 @@ class StarDistOnnxModel(SenoQuantSegmentationModel):
         Parameters
         ----------
         layer : object or None
-            Napari layer to convert.
+            napari layer to convert.
         required : bool
             Whether a missing layer should raise an error.
 
@@ -263,6 +266,9 @@ class StarDistOnnxModel(SenoQuantSegmentationModel):
         session = self._sessions.get(model_path)
         if session is None or providers_override is not None:
             providers = providers_override or self._preferred_providers()
+            preload = getattr(ort, "preload_dlls", None)
+            if callable(preload):
+                preload()
             session = ort.InferenceSession(
                 str(model_path),
                 providers=providers,
@@ -505,85 +511,13 @@ class StarDistOnnxModel(SenoQuantSegmentationModel):
         libraries are absent, allowing Python utilities to import.
         """
         utils_root = self._get_utils_root()
-        csbdeep_root = utils_root / "_csbdeep"
-        if csbdeep_root.exists():
-            csbdeep_path = str(csbdeep_root)
-            if csbdeep_path not in sys.path:
-                sys.path.insert(0, csbdeep_path)
-
         stardist_pkg = (
             "senoquant.tabs.segmentation.stardist_onnx_utils._stardist"
         )
-        if stardist_pkg not in sys.modules:
-            pkg = types.ModuleType(stardist_pkg)
-            pkg.__path__ = [str(utils_root / "_stardist")]
-            sys.modules[stardist_pkg] = pkg
-
-        base_pkg = f"{stardist_pkg}.lib"
-        lib_dirs = [utils_root / "_stardist" / "lib"]
-        for entry in list(sys.path):
-            if not entry:
-                continue
-            try:
-                candidate = (
-                    Path(entry)
-                    / "senoquant"
-                    / "tabs"
-                    / "segmentation"
-                    / "stardist_onnx_utils"
-                    / "_stardist"
-                    / "lib"
-                )
-            except Exception:
-                continue
-            if candidate.exists():
-                lib_dirs.append(candidate)
-
-        if base_pkg in sys.modules:
-            pkg = sys.modules[base_pkg]
-            pkg.__path__ = [str(p) for p in lib_dirs]
-        else:
-            pkg = types.ModuleType(base_pkg)
-            pkg.__path__ = [str(p) for p in lib_dirs]
-            sys.modules[base_pkg] = pkg
-
-        def _stub(*_args, **_kwargs):
-            raise RuntimeError("StarDist compiled ops are unavailable.")
-
-        has_2d = False
-        has_3d = False
-        for lib_dir in lib_dirs:
-            has_2d = has_2d or any(lib_dir.glob("stardist2d*.so")) or any(
-                lib_dir.glob("stardist2d*.pyd")
-            )
-            has_3d = has_3d or any(lib_dir.glob("stardist3d*.so")) or any(
-                lib_dir.glob("stardist3d*.pyd")
-            )
+        has_2d, has_3d = ensure_stardist_libs(utils_root, stardist_pkg)
         self._has_stardist_2d_lib = has_2d
         self._has_stardist_3d_lib = has_3d
 
-        mod2d = f"{base_pkg}.stardist2d"
-        if has_2d and mod2d in sys.modules:
-            if getattr(sys.modules[mod2d], "__file__", None) is None:
-                del sys.modules[mod2d]
-        if not has_2d and mod2d not in sys.modules:
-            module = types.ModuleType(mod2d)
-            module.c_star_dist = _stub
-            module.c_non_max_suppression_inds_old = _stub
-            module.c_non_max_suppression_inds = _stub
-            sys.modules[mod2d] = module
-
-        mod3d = f"{base_pkg}.stardist3d"
-        if has_3d and mod3d in sys.modules:
-            if getattr(sys.modules[mod3d], "__file__", None) is None:
-                del sys.modules[mod3d]
-        if not has_3d and mod3d not in sys.modules:
-            module = types.ModuleType(mod3d)
-            module.c_star_dist3d = _stub
-            module.c_polyhedron_to_label = _stub
-            module.c_non_max_suppression_inds = _stub
-            sys.modules[mod3d] = module
-
     def _get_rays_class(self):
         """Load and cache the StarDist Rays_GoldenSpiral class."""
         if self._rays_class is not None:

senoquant/tabs/segmentation/stardist_onnx_utils/onnx_framework/inspect/probe.py

@@ -53,6 +53,17 @@ def make_probe_image(
     if model_path is None or input_layout is None:
         return probe
 
+    div_by = None
+    if div_by_cache is not None:
+        div_by = div_by_cache.get(model_path)
+    if div_by is None:
+        try:
+            div_by = infer_div_by(model_path, ndim=image.ndim)
+        except Exception:
+            div_by = None
+        if div_by_cache is not None and div_by is not None:
+            div_by_cache[model_path] = div_by
+
     patterns = None
     if valid_size_cache is not None:
         patterns = valid_size_cache.get(model_path)
@@ -68,24 +79,13 @@ def make_probe_image(
         if valid_size_cache is not None:
             valid_size_cache[model_path] = patterns
 
-    div_by = None
-    if div_by_cache is not None:
-        div_by = div_by_cache.get(model_path)
-    if div_by is None:
-        try:
-            div_by = infer_div_by(model_path, ndim=image.ndim)
-        except Exception:
-            div_by = None
-        if div_by_cache is not None and div_by is not None:
-            div_by_cache[model_path] = div_by
-
     desired = list(probe.shape)
     if patterns:
         desired = [
             max(1, snap_size(int(size), patterns[axis]))
             for axis, size in enumerate(desired)
         ]
-    elif div_by:
+    if div_by:
         desired = [
             max(int(d), (int(size) // int(d)) * int(d)) if d else int(size)
             for size, d in zip(desired, div_by)
@@ -97,4 +97,4 @@ def make_probe_image(
     pads = [(0, max(0, d - s)) for s, d in zip(probe.shape, desired)]
     if any(pad_after > 0 for _, pad_after in pads):
         probe = np.pad(probe, pads, mode="reflect")
-    return probe
+    return probe

senoquant/tabs/segmentation/stardist_onnx_utils/onnx_framework/stardist_libs.py

@@ -0,0 +1,171 @@
+"""Helpers for locating and loading StarDist compiled extensions."""
+
+from __future__ import annotations
+
+import importlib.machinery
+import importlib.util
+import sys
+import types
+from pathlib import Path
+
+
+def ensure_stardist_libs(  # noqa: C901, PLR0912, PLR0915
+    utils_root: Path,
+    stardist_pkg: str,
+) -> tuple[bool, bool]:
+    """Ensure StarDist compiled extensions can be imported.
+
+    Parameters
+    ----------
+    utils_root : pathlib.Path
+        Root path to the ``stardist_onnx_utils`` package.
+    stardist_pkg : str
+        Fully-qualified package name for the vendored StarDist package.
+
+    Returns
+    -------
+    tuple[bool, bool]
+        Tuple of ``(has_2d, has_3d)`` indicating which compiled
+        extensions are available.
+
+    """
+    csbdeep_root = utils_root / "_csbdeep"
+    if csbdeep_root.exists():
+        csbdeep_path = str(csbdeep_root)
+        if csbdeep_path not in sys.path:
+            sys.path.insert(0, csbdeep_path)
+
+    if stardist_pkg not in sys.modules:
+        pkg = types.ModuleType(stardist_pkg)
+        pkg.__path__ = [str(utils_root / "_stardist")]
+        sys.modules[stardist_pkg] = pkg
+
+    base_pkg = f"{stardist_pkg}.lib"
+    lib_dirs: list[Path] = []
+    seen_dirs: set[Path] = set()
+
+    def _append_if_exists(path: Path) -> None:
+        if not path.exists():
+            return
+        resolved = path.resolve()
+        if resolved in seen_dirs:
+            return
+        seen_dirs.add(resolved)
+        lib_dirs.append(resolved)
+
+    _append_if_exists(utils_root / "_stardist" / "lib")
+    for entry in list(sys.path):
+        if not entry:
+            continue
+        try:
+            legacy_candidate = (
+                Path(entry)
+                / "senoquant"
+                / "tabs"
+                / "segmentation"
+                / "stardist_onnx_utils"
+                / "_stardist"
+                / "lib"
+            )
+            ext_candidate = Path(entry) / "senoquant_stardist_ext" / "lib"
+        except (TypeError, ValueError, OSError):
+            continue
+        _append_if_exists(legacy_candidate)
+        _append_if_exists(ext_candidate)
+
+    if base_pkg in sys.modules:
+        pkg = sys.modules[base_pkg]
+        pkg.__path__ = [str(p) for p in lib_dirs]
+    else:
+        pkg = types.ModuleType(base_pkg)
+        pkg.__path__ = [str(p) for p in lib_dirs]
+        sys.modules[base_pkg] = pkg
+
+    for module_name in (f"{base_pkg}.stardist2d", f"{base_pkg}.stardist3d"):
+        try:
+            spec = importlib.util.find_spec(module_name)
+        except (ImportError, AttributeError, ValueError):
+            spec = None
+        if spec and spec.origin:
+            try:
+                candidate = Path(spec.origin).parent
+            except (TypeError, OSError):
+                candidate = None
+            if candidate is not None and candidate.exists():
+                lib_dirs.append(candidate)
+
+    mod2d = f"{base_pkg}.stardist2d"
+    mod3d = f"{base_pkg}.stardist3d"
+
+    def _stub(*_args: object, **_kwargs: object) -> None:
+        msg = "StarDist compiled ops are unavailable."
+        raise RuntimeError(msg)
+
+    def _module_available(module_name: str) -> bool:
+        module = sys.modules.get(module_name)
+        if module is not None:
+            return getattr(module, "__file__", None) is not None
+        try:
+            spec = importlib.util.find_spec(module_name)
+        except (ImportError, AttributeError, ValueError):
+            return False
+        return bool(spec and spec.origin)
+
+    def _try_load_dll(module_name: str, dll_path: Path) -> bool:
+        try:
+            loader = importlib.machinery.ExtensionFileLoader(
+                module_name,
+                str(dll_path),
+            )
+            spec = importlib.util.spec_from_file_location(
+                module_name,
+                str(dll_path),
+                loader=loader,
+            )
+            if spec is None or spec.loader is None:
+                return False
+            module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(module)
+            sys.modules[module_name] = module
+        except (ImportError, OSError, AttributeError, ValueError):
+            return False
+        else:
+            return True
+
+    if not _module_available(mod2d):
+        for lib_dir in lib_dirs:
+            candidates = sorted(lib_dir.glob("stardist2d*.dll"))
+            if candidates and _try_load_dll(mod2d, candidates[0]):
+                break
+    if not _module_available(mod3d):
+        for lib_dir in lib_dirs:
+            candidates = sorted(lib_dir.glob("stardist3d*.dll"))
+            if candidates and _try_load_dll(mod3d, candidates[0]):
+                break
+
+    has_2d = _module_available(mod2d)
+    has_3d = _module_available(mod3d)
+
+    if has_2d and mod2d in sys.modules and getattr(
+        sys.modules[mod2d], "__file__", None,
+    ) is None:
+        del sys.modules[mod2d]
+    if not has_2d and mod2d not in sys.modules:
+        module = types.ModuleType(mod2d)
+        module.c_star_dist = _stub  # type: ignore[attr-defined]
+        module.c_non_max_suppression_inds_old = _stub  # type: ignore[attr-defined]
+        module.c_non_max_suppression_inds = _stub  # type: ignore[attr-defined]
+        sys.modules[mod2d] = module
+
+    if has_3d and mod3d in sys.modules and getattr(
+        sys.modules[mod3d], "__file__", None,
+    ) is None:
+        del sys.modules[mod3d]
+    if not has_3d and mod3d not in sys.modules:
+        module = types.ModuleType(mod3d)
+        module.c_star_dist3d = _stub  # type: ignore[attr-defined]
+        module.c_polyhedron_to_label = _stub  # type: ignore[attr-defined]
+        module.c_non_max_suppression_inds = _stub  # type: ignore[attr-defined]
+        sys.modules[mod3d] = module
+
+    return has_2d, has_3d

senoquant/tabs/spots/frontend.py

@@ -118,7 +118,7 @@ class SpotsTab(QWidget):
     backend : SpotsBackend or None
         Backend instance used to discover and load detectors.
     napari_viewer : object or None
-        Napari viewer used to populate layer choices.
+        napari viewer used to populate layer choices.
     """
 
     def __init__(
@@ -491,11 +491,15 @@ class SpotsTab(QWidget):
         detector = self._backend.get_detector(detector_name)
         layer = self._get_layer_by_name(self._layer_combo.currentText())
         settings = self._collect_settings()
+
+        def run_detector() -> dict:
+            return detector.run(layer=layer, settings=settings)
+
         self._start_background_run(
             run_button=self._run_button,
             run_text="Run",
             detector_name=detector_name,
-            run_callable=lambda: detector.run(layer=layer, settings=settings),
+            run_callable=run_detector,
             on_success=lambda result: self._handle_run_result(
                 layer, detector_name, result
             ),
@@ -653,8 +657,41 @@ class SpotsTab(QWidget):
         if self._viewer is None or source_layer is None:
             return
         name = self._spot_label_name(source_layer, detector_name)
-        self._viewer.add_labels(mask, name=name)
-        labels_layer = self._viewer.layers[name]
+        source_metadata = getattr(source_layer, "metadata", {})
+        merged_metadata: dict[str, object] = {}
+        if isinstance(source_metadata, dict):
+            merged_metadata.update(source_metadata)
+        merged_metadata["task"] = "spots"
+
+        labels_layer = None
+        if Labels is not None and hasattr(self._viewer, "add_layer"):
+            # Add a fully configured Labels layer object to avoid name-based lookup.
+            labels_layer = Labels(
+                mask,
+                name=name,
+                metadata=merged_metadata,
+            )
+            added_layer = self._viewer.add_layer(labels_layer)
+            if added_layer is not None:
+                labels_layer = added_layer
+        elif hasattr(self._viewer, "add_labels"):
+            try:
+                labels_layer = self._viewer.add_labels(
+                    mask,
+                    name=name,
+                    metadata=merged_metadata,
+                )
+            except TypeError:
+                labels_layer = self._viewer.add_labels(mask, name=name)
+
+        if labels_layer is None:
+            return
+
+        layer_metadata = getattr(labels_layer, "metadata", {})
+        if isinstance(layer_metadata, dict):
+            merged_metadata.update(layer_metadata)
+        merged_metadata["task"] = "spots"
+        labels_layer.metadata = merged_metadata
         labels_layer.contour = 1
 
     def _apply_size_filter(self, mask: np.ndarray) -> np.ndarray:
@@ -722,7 +759,7 @@ class SpotsTab(QWidget):
         Parameters
         ----------
         layer : object or None
-            Napari layer to validate.
+            napari layer to validate.
         label : str
             User-facing label for notifications.
 

senoquant/tabs/spots/models/ufish/details.json

@@ -0,0 +1,17 @@
+{
+  "name": "ufish",
+  "description": "U-FISH local-maxima seeded watershed detector",
+  "version": "0.1.0",
+  "order": 0,
+  "settings": [
+    {
+      "key": "threshold",
+      "label": "Threshold",
+      "type": "float",
+      "decimals": 2,
+      "min": 0.0,
+      "max": 1.0,
+      "default": 0.5
+    }
+  ]
+}

senoquant/tabs/spots/models/ufish/model.py

@@ -0,0 +1,129 @@
+"""U-FISH local-maxima seeded watershed detector."""
+
+from __future__ import annotations
+
+import numpy as np
+from scipy import ndimage as ndi
+from skimage.filters import laplace
+from skimage.morphology import local_maxima
+from skimage.segmentation import watershed
+
+from ..base import SenoQuantSpotDetector
+from senoquant.utils import layer_data_asarray
+from senoquant.tabs.spots.ufish_utils import UFishConfig, enhance_image
+
+
+DEFAULT_THRESHOLD = 0.5
+USE_LAPLACE_FOR_PEAKS = False
+
+
+def _clamp_threshold(value: float) -> float:
+    """Clamp threshold to the inclusive [0.0, 1.0] range."""
+    return float(np.clip(value, 0.0, 1.0))
+
+
+def _normalize_unit(image: np.ndarray) -> np.ndarray:
+    """Normalize to float32 in [0, 1] using 0.05/99.95 percentiles."""
+    data = np.asarray(image, dtype=np.float32)
+    low, high = np.nanpercentile(data, [0.05, 99.95])
+    low = float(low)
+    high = float(high)
+    if high <= low:
+        return np.zeros_like(data, dtype=np.float32)
+    normalized = (data - low) / (high - low)
+    return np.clip(normalized, 0.0, 1.0).astype(np.float32, copy=False)
+
+
+def _markers_from_local_maxima(
+    enhanced: np.ndarray,
+    threshold: float,
+    use_laplace: bool = True,
+) -> np.ndarray:
+    """Build marker labels from U-FISH local maxima calls."""
+    connectivity = max(1, min(2, enhanced.ndim))
+    response = (
+        laplace(enhanced.astype(np.float32, copy=False))
+        if use_laplace
+        else np.asarray(enhanced, dtype=np.float32)
+    )
+    mask = local_maxima(response, connectivity=connectivity)
+    mask = mask & (response > threshold)
+
+    markers = np.zeros(enhanced.shape, dtype=np.int32)
+    coords = np.argwhere(mask)
+    if coords.size == 0:
+        return markers
+
+    max_indices = np.asarray(enhanced.shape) - 1
+    coords = np.clip(coords, 0, max_indices)
+    markers[tuple(coords.T)] = 1
+
+    structure = ndi.generate_binary_structure(enhanced.ndim, 1)
+    marker_labels, _num = ndi.label(markers > 0, structure=structure)
+    return marker_labels.astype(np.int32, copy=False)
+
+
+def _segment_from_markers(
+    enhanced: np.ndarray,
+    markers: np.ndarray,
+    threshold: float,
+) -> np.ndarray:
+    """Run watershed from local-maxima markers inside threshold foreground."""
+    foreground = enhanced > threshold
+    if not np.any(foreground):
+        return np.zeros_like(enhanced, dtype=np.int32)
+
+    seeded_markers = markers * foreground.astype(np.int32, copy=False)
+    if not np.any(seeded_markers > 0):
+        return np.zeros_like(enhanced, dtype=np.int32)
+
+    labels = watershed(
+        -enhanced.astype(np.float32, copy=False),
+        markers=seeded_markers,
+        mask=foreground,
+    )
+    return labels.astype(np.int32, copy=False)
+
+
+class UFishDetector(SenoQuantSpotDetector):
+    """Spot detector using U-FISH local maxima and watershed expansion."""
+
+    def __init__(self, models_root=None) -> None:
+        super().__init__("ufish", models_root=models_root)
+
+    def run(self, **kwargs) -> dict:
+        """Run U-FISH seeded watershed and return instance labels."""
+        layer = kwargs.get("layer")
+        if layer is None:
+            return {"mask": None, "points": None}
+        if getattr(layer, "rgb", False):
+            raise ValueError("U-FISH detector requires single-channel images.")
+
+        settings = kwargs.get("settings", {}) or {}
+        threshold = _clamp_threshold(float(settings.get("threshold", DEFAULT_THRESHOLD)))
+        use_laplace = USE_LAPLACE_FOR_PEAKS
+
+        data = layer_data_asarray(layer)
+        if data.ndim not in (2, 3):
+            raise ValueError("U-FISH detector expects 2D images or 3D stacks.")
+
+        # Percentile normalize the data
+        data = _normalize_unit(data)
+
+        enhanced = enhance_image(np.asarray(data, dtype=np.float32), config=UFishConfig())
+        enhanced = np.asarray(enhanced, dtype=np.float32)
+
+        # Re-normalize after enhancement
+        enhanced = _normalize_unit(enhanced)
+
+        markers = _markers_from_local_maxima(
+            enhanced,
+            threshold,
+            use_laplace=use_laplace,
+        )
+        labels = _segment_from_markers(
+            enhanced,
+            markers,
+            threshold,
+        )
+        return {"mask": labels}

senoquant/tabs/spots/ufish_utils/__init__.py

@@ -0,0 +1,13 @@
+"""Public UFish utility API for spot enhancement.
+
+This package exposes a minimal stable surface used by the Spots tab:
+
+``UFishConfig``
+    Configuration dataclass for model initialization and weight loading.
+``enhance_image``
+    Convenience function that runs UFish enhancement on an input image.
+"""
+
+from .core import UFishConfig, enhance_image
+
+__all__ = ["UFishConfig", "enhance_image"]