senoquant 1.0.0b1__py3-none-any.whl

senoquant/tabs/segmentation/models/__init__.py

@@ -0,0 +1,5 @@
+"""Segmentation model definitions and storage."""
+
+from .base import SenoQuantSegmentationModel
+
+__all__ = ["SenoQuantSegmentationModel"]

senoquant/tabs/segmentation/models/base.py

@@ -0,0 +1,146 @@
+"""Model wrapper for segmentation resources."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+
+class SenoQuantSegmentationModel:
+    """Handle per-model storage and metadata paths.
+
+    Parameters
+    ----------
+    name : str
+        Model identifier used for folder creation.
+    models_root : pathlib.Path or None
+        Optional root folder for model storage.
+    """
+
+    def __init__(self, name: str, models_root: Path | None = None) -> None:
+        """Initialize the model wrapper and ensure its folder exists."""
+        if not name:
+            raise ValueError("Model name must be non-empty.")
+
+        self.name = name
+        self.models_root = models_root or Path(__file__).parent
+        self.model_dir = self.models_root / name
+        self.model_dir.mkdir(parents=True, exist_ok=True)
+
+    @property
+    def details_path(self) -> Path:
+        """Return the path to the details JSON file."""
+        return self.model_dir / "details.json"
+
+    @property
+    def class_path(self) -> Path:
+        """Return the path to the model class file."""
+        return self.model_dir / "model.py"
+
+    def load_details(self) -> dict:
+        """Load model metadata from the details file.
+
+        Returns
+        -------
+        dict
+            Parsed model metadata dictionary.
+        """
+        if not self.details_path.exists():
+            return {}
+        with self.details_path.open("r", encoding="utf-8") as handle:
+            return json.load(handle)
+
+    def run(self, **kwargs) -> dict | None:
+        """Run the model with the provided inputs and settings.
+
+        Parameters
+        ----------
+        **kwargs
+            Model inputs and settings passed from the UI.
+
+        Returns
+        -------
+        dict or None
+            Result dictionary from the model, or None if not implemented.
+        """
+        raise NotImplementedError("Model run not implemented.")
+
+    def list_settings(self) -> list[dict]:
+        """Return the settings definitions for this model.
+
+        Returns
+        -------
+        list[dict]
+            Settings definitions for building the UI.
+        """
+        details = self.load_details()
+        settings = details.get("settings", [])
+        if isinstance(settings, list):
+            return settings
+        return []
+
+    def display_order(self) -> float | None:
+        """Return the optional display ordering for this model.
+
+        Returns
+        -------
+        float or None
+            Numeric ordering value if specified in details.json.
+        """
+        details = self.load_details()
+        order = details.get("order")
+        if isinstance(order, (int, float)):
+            return float(order)
+        if isinstance(order, str):
+            try:
+                return float(order)
+            except ValueError:
+                return None
+        return None
+
+    def supports_task(self, task: str) -> bool:
+        """Return whether the model supports a given task.
+
+        Parameters
+        ----------
+        task : str
+            Task name, such as "nuclear" or "cytoplasmic".
+
+        Returns
+        -------
+        bool
+            True if the task is supported.
+        """
+        details = self.load_details()
+        tasks = details.get("tasks", {})
+        task_info = tasks.get(task, {})
+        return bool(task_info.get("supported", False))
+
+    def cytoplasmic_input_modes(self) -> list[str]:
+        """Return supported input modes for cytoplasmic segmentation.
+
+        Returns
+        -------
+        list[str]
+            Input modes, e.g., "cytoplasmic" or "nuclear+cytoplasmic".
+        """
+        details = self.load_details()
+        tasks = details.get("tasks", {})
+        task_info = tasks.get("cytoplasmic", {})
+        modes = task_info.get("input_modes", [])
+        if isinstance(modes, list):
+            return modes
+        return []
+
+    def cytoplasmic_nuclear_optional(self) -> bool:
+        """Return whether the nuclear channel is optional for cytoplasmic mode.
+
+        Returns
+        -------
+        bool
+            True when the nuclear channel is optional.
+        """
+        details = self.load_details()
+        tasks = details.get("tasks", {})
+        task_info = tasks.get("cytoplasmic", {})
+        return bool(task_info.get("nuclear_channel_optional", False))

senoquant/tabs/segmentation/models/cpsam/details.json

@@ -0,0 +1,65 @@
+{
+  "name": "cpsam",
+  "description": "Cellpose SAM model",
+  "version": "0.1.0",
+  "order": 3,
+  "tasks": {
+    "nuclear": {
+      "supported": true
+    },
+    "cytoplasmic": {
+      "supported": true,
+      "input_modes": ["cytoplasmic", "nuclear+cytoplasmic"],
+      "nuclear_channel_optional": true
+    }
+  },
+  "settings": [
+    {
+      "key": "diameter",
+      "label": "Diameter",
+      "type": "float",
+      "decimals": 1,
+      "min": 0.1,
+      "max": 1000.0,
+      "default": 30.0
+    },
+    {
+      "key": "flow_threshold",
+      "label": "Flow threshold",
+      "type": "float",
+      "decimals": 1,
+      "min": 0.0,
+      "max": 2.0,
+      "default": 0.4
+    },
+    {
+      "key": "cellprob_threshold",
+      "label": "Cellprob threshold",
+      "type": "float",
+      "decimals": 1,
+      "min": -6.0,
+      "max": 6.0,
+      "default": 0.0
+    },
+    {
+      "key": "n_iterations",
+      "label": "Number of iterations",
+      "type": "int",
+      "min": 0,
+      "max": 9999,
+      "default": 0
+    },
+    {
+      "key": "use_3d",
+      "label": "3D",
+      "type": "bool",
+      "default": false
+    },
+    {
+      "key": "normalize",
+      "label": "Normalize",
+      "type": "bool",
+      "default": true
+    }
+  ]
+}

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

@@ -0,0 +1,150 @@
+"""CPSAM segmentation model implementation."""
+
+from __future__ import annotations
+
+from pathlib import Path
+import numpy as np
+
+from senoquant.utils import layer_data_asarray
+from ..hf import DEFAULT_REPO_ID, ensure_hf_model
+from ..base import SenoQuantSegmentationModel
+
+
+class CPSAMModel(SenoQuantSegmentationModel):
+    """CPSAM segmentation model implementation."""
+
+    def __init__(self, models_root=None) -> None:
+        """Initialize the CPSAM model wrapper."""
+        super().__init__("cpsam", models_root=models_root)
+        from cellpose.models import CellposeModel
+
+        model_path = Path(self.model_dir) / "cpsam"
+        if not model_path.exists():
+            try:
+                model_path = ensure_hf_model(
+                    "cpsam",
+                    self.model_dir,
+                    repo_id=DEFAULT_REPO_ID,
+                )
+            except RuntimeError:
+                pass
+        # Always request GPU; Cellpose will fall back if unavailable.
+        self._model = CellposeModel(gpu=True, pretrained_model=str(model_path))
+
+    def run(self, **kwargs) -> dict:
+        """Run CPSAM using the Cellpose API.
+
+        Parameters
+        ----------
+        **kwargs
+            task : str
+                Segmentation task ("nuclear" or "cytoplasmic").
+            layer : napari.layers.Image or None
+                Nuclear image layer for nuclear task.
+            cytoplasmic_layer : napari.layers.Image or None
+                Cytoplasmic image layer for cytoplasmic task.
+            nuclear_layer : napari.layers.Image or None
+                Nuclear image layer for cytoplasmic task.
+            settings : dict
+                Model settings keyed by the details.json schema.
+
+        Returns
+        -------
+        dict
+            Dictionary containing masks, flows, and styles from Cellpose.
+        """
+        task = kwargs.get("task")
+        settings = kwargs.get("settings", {})
+
+        do_3d = bool(settings.get("use_3d", False))
+        normalize = bool(settings.get("normalize", True))
+        diameter = settings.get("diameter")
+        flow_threshold = settings.get("flow_threshold", 0.4)
+        cellprob_threshold = settings.get("cellprob_threshold", 0.0)
+        n_iterations = settings.get("n_iterations", 0)
+
+        if task == "nuclear":
+            layer = kwargs.get("layer")
+            image = self._extract_layer_data(layer, required=True)
+            input_data = self._prepare_input(image)
+        elif task == "cytoplasmic":
+            cyto_layer = kwargs.get("cytoplasmic_layer")
+            nuclear_layer = kwargs.get("nuclear_layer")
+            cyto_image = self._extract_layer_data(cyto_layer, required=True)
+            nuclear_image = self._extract_layer_data(
+                nuclear_layer, required=False
+            )
+            if nuclear_image is None:
+                input_data = self._prepare_input(cyto_image)
+            else:
+                input_data = self._prepare_input(
+                    nuclear_image,
+                    cyto_image,
+                )
+        else:
+            raise ValueError("Unknown task for CPSAM.")
+
+        masks, flows, styles = self._model.eval(
+            input_data,
+            normalize=normalize,
+            diameter=diameter,
+            flow_threshold=flow_threshold,
+            cellprob_threshold=cellprob_threshold,
+            do_3D=do_3d,
+            z_axis=0 if do_3d else None,
+            niter=n_iterations,
+        )
+
+        return {"masks": masks, "flows": flows, "styles": styles}
+
+    def _extract_layer_data(self, layer, required: bool) -> np.ndarray | None:
+        """Return numpy data for the given napari layer.
+
+        Parameters
+        ----------
+        layer : object or None
+            Napari layer to convert.
+        required : bool
+            Whether a missing layer should raise an error.
+
+        Returns
+        -------
+        numpy.ndarray or None
+            Layer data or None if not required and missing.
+        """
+        if layer is None:
+            if required:
+                raise ValueError("Layer is required for CPSAM.")
+            return None
+        return layer_data_asarray(layer)
+
+    def _prepare_input(
+        self,
+        nuclear: np.ndarray,
+        cytoplasmic: np.ndarray | None = None,
+    ) -> np.ndarray:
+        """Prepare CPSAM input as YX, ZYX, CYX, or ZCYX.
+
+        Parameters
+        ----------
+        nuclear : numpy.ndarray
+            Nuclear image data.
+        cytoplasmic : numpy.ndarray or None
+            Cytoplasmic image data, when provided.
+
+        Returns
+        -------
+        numpy.ndarray
+            Input array suitable for Cellpose eval.
+        """
+        if nuclear.ndim not in (2, 3):
+            raise ValueError("Input image must be 2D or 3D.")
+        if cytoplasmic is not None and cytoplasmic.shape != nuclear.shape:
+            raise ValueError("Nuclear and cytoplasmic images must match in shape.")
+
+        if cytoplasmic is None:
+            return nuclear.astype(np.float32)
+
+        axis = 0 if nuclear.ndim == 2 else 1
+        stacked = np.stack([nuclear, cytoplasmic], axis=axis)
+        return stacked.astype(np.float32)

senoquant/tabs/segmentation/models/default_2d/details.json

@@ -0,0 +1,69 @@
+{
+  "name": "default_2d",
+  "description": "Fine-tuned StarDist 2D model for nuclear segmentation.",
+  "version": "0.1.0",
+  "order": 1,
+  "tasks": {
+    "nuclear": {
+      "supported": true
+    },
+    "cytoplasmic": {
+      "supported": false
+    }
+  },
+  "settings": [
+    {
+      "key": "object_diameter_px",
+      "label": "Object diameter (px)",
+      "type": "float",
+      "decimals": 1,
+      "min": 1.0,
+      "max": 500.0,
+      "default": 30.0
+    },
+    {
+      "key": "prob_thresh",
+      "label": "Prob threshold",
+      "type": "float",
+      "decimals": 3,
+      "min": 0.0,
+      "max": 1.0,
+      "default": 0.496187
+    },
+    {
+      "key": "nms_thresh",
+      "label": "NMS threshold",
+      "type": "float",
+      "decimals": 3,
+      "min": 0.0,
+      "max": 1.0,
+      "default": 0.3
+    },
+    {
+      "key": "normalize",
+      "label": "Normalize",
+      "type": "bool",
+      "default": true
+    },
+    {
+      "key": "pmin",
+      "label": "Percentile min",
+      "type": "float",
+      "decimals": 1,
+      "min": 0.0,
+      "max": 100.0,
+      "default": 1.0,
+      "enabled_by": "normalize"
+    },
+    {
+      "key": "pmax",
+      "label": "Percentile max",
+      "type": "float",
+      "decimals": 1,
+      "min": 0.0,
+      "max": 100.0,
+      "default": 99.8,
+      "enabled_by": "normalize"
+    }
+  ]
+}