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

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
             ),
@@ -647,16 +651,103 @@ class SpotsTab(QWidget):
         if mask is not None:
             filtered_mask = self._apply_size_filter(mask)
             self._add_labels_layer(layer, filtered_mask, detector_name)
+        debug_images = result.get("debug_images")
+        if isinstance(debug_images, dict):
+            self._add_debug_image_layers(layer, detector_name, debug_images)
 
     def _add_labels_layer(self, source_layer, mask, detector_name: str) -> None:
         """Add a labels layer for the detector mask."""
         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 _add_debug_image_layers(
+        self,
+        source_layer,
+        detector_name: str,
+        debug_images: dict,
+    ) -> None:
+        """Add debug image layers emitted by a detector run."""
+        if self._viewer is None:
+            return
+        source_name = getattr(source_layer, "name", "") if source_layer is not None else ""
+        source_name = source_name.strip() if isinstance(source_name, str) else ""
+
+        for debug_key, debug_image in debug_images.items():
+            if debug_image is None:
+                continue
+            image_data = np.asarray(debug_image)
+            if image_data.size == 0:
+                continue
+            layer_name = f"{detector_name}_{debug_key}"
+            if source_name:
+                layer_name = f"{source_name}_{layer_name}"
+            if layer_name in self._viewer.layers:
+                self._viewer.layers.remove(layer_name)
+
+            metadata = {"task": "spots", "debug": True}
+            image_layer = None
+            if Image is not None and hasattr(self._viewer, "add_layer"):
+                image_layer = Image(
+                    image_data,
+                    name=layer_name,
+                    metadata=metadata,
+                )
+                added_layer = self._viewer.add_layer(image_layer)
+                if added_layer is not None:
+                    image_layer = added_layer
+            elif hasattr(self._viewer, "add_image"):
+                try:
+                    image_layer = self._viewer.add_image(
+                        image_data,
+                        name=layer_name,
+                        metadata=metadata,
+                    )
+                except TypeError:
+                    image_layer = self._viewer.add_image(
+                        image_data,
+                        name=layer_name,
+                    )
+
+            if image_layer is not None:
+                image_layer.visible = True
+
     def _apply_size_filter(self, mask: np.ndarray) -> np.ndarray:
         """Filter spots by size based on min/max settings.
         
@@ -722,7 +813,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/rmp/details.json

@@ -1,8 +1,8 @@
 {
   "name": "rmp",
-  "description": "Placeholder details for the rmp spot detector",
+  "description": "RMP spot detector implementation",
   "version": "0.1.0",
-  "order": 2,
+  "order": 0,
   "settings": [
     {
       "key": "denoising_kernel_length",
@@ -17,7 +17,7 @@
       "key": "extraction_kernel_length",
       "label": "Extraction kernel length",
       "type": "int",
-      "min": 1,
+      "min": 3,
       "max": 9999,
       "default": 10
     },
@@ -50,12 +50,6 @@
       "label": "Enable denoising",
       "type": "bool",
       "default": true
-    },
-    {
-      "key": "use_3d",
-      "label": "3D",
-      "type": "bool",
-      "default": false
     }
   ]
 }