senoquant 1.0.0b1__py3-none-any.whl

senoquant/tabs/segmentation/models/hf.py

@@ -0,0 +1,71 @@
+"""Hugging Face model download utilities."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+try:
+    from huggingface_hub import hf_hub_download  # type: ignore[import-not-found]
+except ImportError:  # pragma: no cover - optional dependency
+    hf_hub_download = None
+
+
+def _resolve_repo_id(default_repo: str) -> str:
+    """Resolve the model repository ID from environment or default."""
+    env_repo = os.environ.get("SENOQUANT_MODEL_REPO")
+    if env_repo:
+        return env_repo.strip()
+    return default_repo
+
+
+DEFAULT_REPO_ID = "HaamsRee/senoquant-models"
+
+
+def ensure_hf_model(
+    filename: str,
+    target_dir: Path,
+    *,
+    repo_id: str,
+    revision: str | None = None,
+) -> Path:
+    """Ensure a model file exists, downloading from HF if needed.
+
+    Parameters
+    ----------
+    filename : str
+        File name to download from the HF repo.
+    target_dir : pathlib.Path
+        Local directory for the model file.
+    repo_id : str
+        Hugging Face repo id, e.g. "HaamsRee/senoquant-models".
+    revision : str or None, optional
+        Optional revision/tag/commit to pin.
+
+    Returns
+    -------
+    pathlib.Path
+        Local path to the downloaded model file.
+
+    """
+    target_dir = Path(target_dir)
+    target_dir.mkdir(parents=True, exist_ok=True)
+    candidate = target_dir / filename
+    if candidate.exists():
+        return candidate
+
+    if hf_hub_download is None:
+        message = (
+            "huggingface_hub is required to download models. "
+            "Install it with `pip install huggingface_hub`."
+        )
+        raise RuntimeError(message)
+
+    resolved_repo = _resolve_repo_id(repo_id)
+    path = hf_hub_download(
+        repo_id=resolved_repo,
+        filename=filename,
+        revision=revision,
+        local_dir=str(target_dir),
+    )
+    return Path(path)

senoquant/tabs/segmentation/models/nuclear_dilation/__init__.py

@@ -0,0 +1 @@
+"""Nuclear dilation segmentation model."""

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

@@ -0,0 +1,26 @@
+{
+  "name": "nuclear_dilation",
+  "description": "Dilates nuclear masks to approximate cytoplasm",
+  "version": "0.1.0",
+  "order": 4,
+  "tasks": {
+    "nuclear": {
+      "supported": false
+    },
+    "cytoplasmic": {
+      "supported": true,
+      "input_modes": ["nuclear"],
+      "nuclear_channel_optional": false
+    }
+  },
+  "settings": [
+    {
+      "key": "dilation_iterations",
+      "label": "Dilation iterations",
+      "type": "int",
+      "min": 1,
+      "max": 100,
+      "default": 5
+    }
+  ]
+}

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

@@ -0,0 +1,96 @@
+"""Nuclear dilation cytoplasmic segmentation model."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import numpy as np
+from scipy import ndimage as ndi
+
+from senoquant.tabs.segmentation.models.base import SenoQuantSegmentationModel
+from senoquant.utils import layer_data_asarray
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+class NuclearDilationModel(SenoQuantSegmentationModel):
+    """Dilates nuclear masks to approximate cytoplasm.
+
+    This model only requires a nuclear segmentation mask and dilates it
+    to approximate cytoplasmic boundaries. It is useful when cytoplasmic
+    staining is weak or unavailable.
+
+    Notes
+    -----
+    - Only supports cytoplasmic segmentation task.
+    - Requires nuclear_layer, ignores cytoplasmic_layer.
+
+    """
+
+    def __init__(self, models_root: Path | None = None) -> None:
+        """Initialize the nuclear dilation model wrapper.
+
+        Parameters
+        ----------
+        models_root : pathlib.Path or None
+            Optional root directory for model storage.
+
+        """
+        super().__init__("nuclear_dilation", models_root=models_root)
+
+    def run(self, **kwargs: object) -> dict:
+        """Run nuclear dilation for cytoplasmic segmentation.
+
+        Parameters
+        ----------
+        **kwargs
+            task : str
+                Must be "cytoplasmic" for this model.
+            nuclear_layer : napari.layers.Labels
+                Nuclear segmentation mask layer.
+            cytoplasmic_layer : napari.layers.Image or None
+                Ignored by this model.
+            settings : dict
+                Model settings keyed by ``details.json``.
+
+        Returns
+        -------
+        dict
+            Dictionary with:
+            - ``masks``: dilated nuclear label image
+
+        """
+        task = kwargs.get("task")
+        if task != "cytoplasmic":
+            msg = "Nuclear dilation only supports cytoplasmic segmentation."
+            raise ValueError(msg)
+
+        nuclear_layer = kwargs.get("nuclear_layer")
+        settings = kwargs.get("settings", {})
+
+        if nuclear_layer is None:
+            msg = "Nuclear layer is required for nuclear dilation."
+            raise ValueError(msg)
+
+        nuclear_data = layer_data_asarray(nuclear_layer)
+        if nuclear_data is None:
+            msg = "Failed to read nuclear layer data."
+            raise ValueError(msg)
+
+        nuclear_data = nuclear_data.astype(np.uint32, copy=False)
+        settings_dict = {} if not isinstance(settings, dict) else settings
+        dilation_iterations = max(int(settings_dict.get("dilation_iterations", 5)), 1)
+
+        dilated_labels = np.zeros_like(nuclear_data)
+        for label_id in np.unique(nuclear_data):
+            if label_id == 0:
+                continue
+            mask = nuclear_data == label_id
+            dilated_mask = ndi.binary_dilation(
+                mask,
+                iterations=dilation_iterations,
+            )
+            dilated_labels[dilated_mask] = label_id
+
+        return {"masks": dilated_labels}

senoquant/tabs/segmentation/models/perinuclear_rings/__init__.py

@@ -0,0 +1 @@
+"""Perinuclear rings cytoplasmic segmentation model."""

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

@@ -0,0 +1,34 @@
+{
+  "name": "perinuclear_rings",
+  "description": "Creates perinuclear rings from nuclear masks",
+  "version": "0.1.0",
+  "order": 5,
+  "tasks": {
+    "nuclear": {
+      "supported": false
+    },
+    "cytoplasmic": {
+      "supported": true,
+      "input_modes": ["nuclear"],
+      "nuclear_channel_optional": false
+    }
+  },
+  "settings": [
+    {
+      "key": "erosion_px",
+      "label": "Inner erosion (px)",
+      "type": "int",
+      "min": 1,
+      "max": 50,
+      "default": 2
+    },
+    {
+      "key": "dilation_px",
+      "label": "Outer dilation (px)",
+      "type": "int",
+      "min": 0,
+      "max": 50,
+      "default": 5
+    }
+  ]
+}

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

@@ -0,0 +1,132 @@
+"""Perinuclear rings cytoplasmic segmentation model."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import numpy as np
+from scipy import ndimage as ndi
+
+from senoquant.tabs.segmentation.models.base import SenoQuantSegmentationModel
+from senoquant.utils import layer_data_asarray
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+class PerinuclearRingsModel(SenoQuantSegmentationModel):
+    """Creates perinuclear rings from nuclear masks.
+
+    This model generates ring-shaped labels around nuclei by eroding the
+    nuclear mask inward and dilating it outward, then subtracting the
+    eroded mask from the dilated mask. This is useful for detecting
+    perinuclear markers that localize to the region immediately
+    surrounding the nucleus.
+
+    The erosion parameter has a minimum of 1 pixel to ensure that the
+    resulting rings maintain at least 1 pixel overlap with the original
+    nuclear labels, which is required for label relationship logic in
+    quantification and batch processing.
+
+    Notes
+    -----
+    - Only supports cytoplasmic segmentation task.
+    - Requires nuclear_layer, ignores cytoplasmic_layer.
+    - Maintains label IDs from the original nuclear segmentation.
+
+    """
+
+    def __init__(self, models_root: Path | None = None) -> None:
+        """Initialize the perinuclear rings model wrapper.
+
+        Parameters
+        ----------
+        models_root : pathlib.Path or None
+            Optional root directory for model storage.
+
+        """
+        super().__init__("perinuclear_rings", models_root=models_root)
+
+    def run(self, **kwargs: object) -> dict:
+        """Generate perinuclear rings from nuclear segmentation.
+
+        Parameters
+        ----------
+        **kwargs
+            task : str
+                Must be "cytoplasmic" for this model.
+            nuclear_layer : napari.layers.Labels
+                Nuclear segmentation mask layer.
+            cytoplasmic_layer : napari.layers.Image or None
+                Ignored by this model.
+            settings : dict
+                Model settings keyed by ``details.json``:
+                - ``erosion_px``: pixels to erode inward (min 1)
+                - ``dilation_px``: pixels to dilate outward
+
+        Returns
+        -------
+        dict
+            Dictionary with:
+            - ``masks``: perinuclear ring label image
+
+        Raises
+        ------
+        ValueError
+            If task is not "cytoplasmic" or nuclear_layer is missing.
+
+        """
+        task = kwargs.get("task")
+        if task != "cytoplasmic":
+            msg = "Perinuclear rings only supports cytoplasmic segmentation."
+            raise ValueError(msg)
+
+        nuclear_layer = kwargs.get("nuclear_layer")
+        settings = kwargs.get("settings", {})
+
+        if nuclear_layer is None:
+            msg = "Nuclear layer is required for perinuclear rings."
+            raise ValueError(msg)
+
+        nuclear_data = layer_data_asarray(nuclear_layer)
+        if nuclear_data is None:
+            msg = "Failed to read nuclear layer data."
+            raise ValueError(msg)
+
+        nuclear_data = nuclear_data.astype(np.uint32, copy=False)
+        settings_dict = {} if not isinstance(settings, dict) else settings
+        
+        # Ensure erosion is at least 1 pixel for label relationship logic
+        erosion_px = max(int(settings_dict.get("erosion_px", 2)), 1)
+        dilation_px = max(int(settings_dict.get("dilation_px", 5)), 0)
+
+        ring_labels = np.zeros_like(nuclear_data)
+
+        # Process each nucleus individually to maintain label relationships
+        for label_id in np.unique(nuclear_data):
+            if label_id == 0:
+                continue
+            
+            # Create binary mask for this nucleus
+            nucleus_mask = nuclear_data == label_id
+            
+            # Erode inward (minimum 1 px to maintain overlap)
+            eroded_mask = ndi.binary_erosion(
+                nucleus_mask,
+                iterations=erosion_px,
+            )
+            
+            # Dilate outward
+            dilated_mask = ndi.binary_dilation(
+                nucleus_mask,
+                iterations=dilation_px,
+            )
+            
+            # Ring is the difference: dilated - eroded
+            # This creates a ring that includes the original boundary
+            ring_mask = dilated_mask & ~eroded_mask
+            
+            # Assign the original label ID to the ring
+            ring_labels[ring_mask] = label_id
+
+        return {"masks": ring_labels}

senoquant/tabs/segmentation/stardist_onnx_utils/__init__.py

@@ -0,0 +1,2 @@
+"""StarDist ONNX support utilities (vendored StarDist/CSBDeep + helpers)."""
+

senoquant/tabs/segmentation/stardist_onnx_utils/_csbdeep/csbdeep/__init__.py

@@ -0,0 +1,3 @@
+from __future__ import absolute_import, print_function
+from .version import __version__
+

senoquant/tabs/segmentation/stardist_onnx_utils/_csbdeep/csbdeep/data/__init__.py

@@ -0,0 +1,6 @@
+from __future__ import absolute_import
+
+from .transform import *
+from .generate import *
+from .rawdata import *
+from .prepare import *