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

senoquant/__init__.py

@@ -4,7 +4,7 @@ try:
     from importlib.metadata import version
     __version__ = version("senoquant")
 except Exception:
-    __version__ = "1.0.0b3"  # Fallback for development
+    __version__ = "1.0.0b4"  # Fallback for development
 
 from ._widget import SenoQuantWidget
 __all__ = ["SenoQuantWidget"]

senoquant/_widget.py

@@ -2,7 +2,14 @@
 
 from qtpy.QtWidgets import QTabWidget, QVBoxLayout, QWidget
 
-from .tabs import BatchTab, QuantificationTab, SegmentationTab, SettingsTab, SpotsTab
+from .tabs import (
+    BatchTab,
+    QuantificationTab,
+    SegmentationTab,
+    SettingsTab,
+    SpotsTab,
+    VisualizationTab,
+)
 from .tabs.settings.backend import SettingsBackend
 
 
@@ -26,6 +33,7 @@ class SenoQuantWidget(QWidget):
         )
         tabs.addTab(SpotsTab(napari_viewer=napari_viewer), "Spots")
         tabs.addTab(QuantificationTab(napari_viewer=napari_viewer), "Quantification")
+        tabs.addTab(VisualizationTab(napari_viewer=napari_viewer), "Visualization")
         tabs.addTab(BatchTab(napari_viewer=napari_viewer), "Batch")
         tabs.addTab(SettingsTab(backend=self._settings_backend), "Settings")
 

senoquant/tabs/__init__.py

@@ -3,6 +3,7 @@
 from .segmentation.frontend import SegmentationTab
 from .spots.frontend import SpotsTab
 from .quantification.frontend import QuantificationTab
+from .visualization.frontend import VisualizationTab
 from .settings.frontend import SettingsTab
 from .batch.frontend import BatchTab
 
@@ -10,6 +11,7 @@ __all__ = [
     "SegmentationTab",
     "SpotsTab",
     "QuantificationTab",
+    "VisualizationTab",
     "SettingsTab",
     "BatchTab",
 ]

senoquant/tabs/batch/backend.py

@@ -208,7 +208,8 @@ class BatchBackend:
         cyto_channel : str or int or None, optional
             Channel selection for cytoplasm.
         cyto_nuclear_channel : str or int or None, optional
-            Optional nuclear channel used by cytoplasmic models.
+            Optional nuclear input for cytoplasmic models. This may be a
+            channel selection or a generated nuclear label name.
         cyto_settings : dict or None, optional
             Model settings for cytoplasmic segmentation.
         spot_detector : str or None, optional
@@ -260,6 +261,14 @@ class BatchBackend:
         cyto_settings = cyto_settings or {}
         spot_settings = spot_settings or {}
         quant_backend = QuantificationBackend()
+        cyto_model_instance = None
+        cyto_nuclear_only = False
+        if cyto_model:
+            cyto_model_instance = self._segmentation_backend.get_model(cyto_model)
+            modes: list[str] = []
+            if hasattr(cyto_model_instance, "cytoplasmic_input_modes"):
+                modes = cyto_model_instance.cytoplasmic_input_modes()
+            cyto_nuclear_only = modes == ["nuclear"]
 
         # Count total items to process
         total_items = 0
@@ -349,36 +358,61 @@ class BatchBackend:
                             item_result.outputs[label_name] = out_path
 
                     if cyto_model:
-                        channel_idx = resolve_channel_index(
-                            cyto_channel, normalized_channels
-                        )
-                        cyto_image, cyto_meta = load_channel_data(
-                            path, channel_idx, scene_id
-                        )
-                        if cyto_image is None:
-                            raise RuntimeError(
-                                "Failed to read cytoplasmic image data."
-                            )
-                        cyto_layer = Image(cyto_image, "cytoplasmic", cyto_meta)
-                        cyto_nuclear_layer = None
-                        if cyto_nuclear_channel is not None:
-                            nuclear_idx = resolve_channel_index(
-                                cyto_nuclear_channel, normalized_channels
+                        cyto_layer = None
+                        cyto_meta: dict = {}
+                        if not cyto_nuclear_only:
+                            channel_idx = resolve_channel_index(
+                                cyto_channel, normalized_channels
                             )
-                            nuclear_image, nuclear_meta = load_channel_data(
-                                path, nuclear_idx, scene_id
+                            cyto_image, cyto_meta = load_channel_data(
+                                path, channel_idx, scene_id
                             )
-                            if nuclear_image is None:
+                            if cyto_image is None:
                                 raise RuntimeError(
-                                    "Failed to read cytoplasmic nuclear data."
+                                    "Failed to read cytoplasmic image data."
+                                )
+                            cyto_layer = Image(cyto_image, "cytoplasmic", cyto_meta)
+                        cyto_nuclear_layer = None
+                        if cyto_nuclear_channel is not None:
+                            cyto_nuclear_key = str(cyto_nuclear_channel)
+                            if (
+                                cyto_nuclear_only
+                                and cyto_nuclear_key in labels_data
+                            ):
+                                nuclear_meta = labels_meta.get(cyto_nuclear_key, {})
+                                cyto_nuclear_layer = Labels(
+                                    labels_data[cyto_nuclear_key],
+                                    cyto_nuclear_key,
+                                    nuclear_meta,
+                                )
+                                if not cyto_meta:
+                                    cyto_meta = dict(nuclear_meta)
+                            else:
+                                nuclear_idx = resolve_channel_index(
+                                    cyto_nuclear_channel, normalized_channels
                                 )
-                            cyto_nuclear_layer = Image(
-                                nuclear_image, "nuclear", nuclear_meta
+                                nuclear_image, nuclear_meta = load_channel_data(
+                                    path, nuclear_idx, scene_id
+                                )
+                                if nuclear_image is None:
+                                    raise RuntimeError(
+                                        "Failed to read cytoplasmic nuclear data."
+                                    )
+                                cyto_nuclear_layer = Image(
+                                    nuclear_image, "nuclear", nuclear_meta
+                                )
+                                if not cyto_meta:
+                                    cyto_meta = dict(nuclear_meta)
+                        if cyto_nuclear_only and cyto_nuclear_layer is None:
+                            raise RuntimeError(
+                                "Selected cytoplasmic model requires nuclear labels."
                             )
-                        model = self._segmentation_backend.get_model(cyto_model)
-                        seg_result = model.run(
+                        if cyto_model_instance is None:
+                            raise RuntimeError("Failed to load cytoplasmic model.")
+                        seg_result = cyto_model_instance.run(
                             task="cytoplasmic",
                             layer=cyto_layer,
+                            cytoplasmic_layer=cyto_layer,
                             nuclear_layer=cyto_nuclear_layer,
                             settings=cyto_settings,
                         )

senoquant/tabs/batch/frontend.py

@@ -123,6 +123,11 @@ class BatchTab(QWidget):
         self._spot_min_size_spin: QSpinBox | None = None
         self._spot_max_size_spin: QSpinBox | None = None
         self._add_spot_button: QPushButton | None = None
+        self._cyto_nuclear_optional = False
+        self._cyto_nuclear_from_labels = False
+        self._cyto_requires_cyto_channel = True
+        self._cyto_supports_nuclear_input = False
+        self._refreshing_channel_choices = False
         self._config_viewer = BatchViewer()
 
         layout = QVBoxLayout()
@@ -281,6 +286,9 @@ class BatchTab(QWidget):
         self._nuclear_model_combo.currentTextChanged.connect(
             lambda _text: self._update_nuclear_settings()
         )
+        self._nuclear_channel_combo.currentTextChanged.connect(
+            self._on_nuclear_channel_changed
+        )
 
         cyto_layout = QFormLayout()
         cyto_layout.setFieldGrowthPolicy(QFormLayout.AllNonFixedFieldsGrow)
@@ -293,7 +301,6 @@ class BatchTab(QWidget):
         self._cyto_channel_combo = QComboBox()
         self._cyto_nuclear_combo = QComboBox()
         self._cyto_nuclear_label = QLabel("Nuclear channel")
-        self._cyto_nuclear_optional = False
         cyto_layout.addRow(self._cyto_enabled)
         cyto_layout.addRow("Cytoplasmic model", self._cyto_model_combo)
         cyto_layout.addRow("Cytoplasmic channel", self._cyto_channel_combo)
@@ -593,6 +600,9 @@ class BatchTab(QWidget):
 
     def _refresh_channel_choices(self) -> None:
         """Refresh combo boxes that depend on channel mapping."""
+        if self._refreshing_channel_choices:
+            return
+        self._refreshing_channel_choices = True
         names = [config.name for config in self._channel_configs]
 
         def populate_combo(
@@ -600,13 +610,16 @@ class BatchTab(QWidget):
             *,
             include_none: bool = False,
             none_label: str = "(none)",
+            explicit_items: list[str] | None = None,
         ) -> None:
             current = combo.currentText()
             combo.clear()
             items: list[str] = []
             if include_none:
                 items.append(none_label)
-            if names:
+            if explicit_items is not None:
+                items.extend(explicit_items)
+            elif names:
                 items.extend(names)
             elif not include_none:
                 items.append("0")
@@ -618,15 +631,40 @@ class BatchTab(QWidget):
                 if index != -1:
                     combo.setCurrentIndex(index)
 
-        if getattr(self, "_nuclear_channel_combo", None) is not None:
-            populate_combo(self._nuclear_channel_combo)
-        if getattr(self, "_cyto_channel_combo", None) is not None:
-            populate_combo(self._cyto_channel_combo)
-        if getattr(self, "_cyto_nuclear_combo", None) is not None:
-            populate_combo(
-                self._cyto_nuclear_combo,
-                include_none=self._cyto_nuclear_optional,
-            )
+        try:
+            if getattr(self, "_nuclear_channel_combo", None) is not None:
+                populate_combo(self._nuclear_channel_combo)
+            if getattr(self, "_cyto_channel_combo", None) is not None:
+                populate_combo(self._cyto_channel_combo)
+            if getattr(self, "_cyto_nuclear_combo", None) is not None:
+                if self._cyto_nuclear_from_labels:
+                    label_options = self._cyto_nuclear_label_options()
+                    populate_combo(
+                        self._cyto_nuclear_combo,
+                        explicit_items=label_options,
+                        none_label="(no nuclear labels)",
+                    )
+                else:
+                    populate_combo(
+                        self._cyto_nuclear_combo,
+                        include_none=self._cyto_nuclear_optional,
+                    )
+        finally:
+            self._refreshing_channel_choices = False
+
+    def _cyto_nuclear_label_options(self) -> list[str]:
+        """Return available nuclear label names for nuclear-only cyto models."""
+        if getattr(self, "_nuclear_enabled", None) is None:
+            return []
+        if not self._nuclear_enabled.isChecked():
+            return []
+        nuclear_model = self._nuclear_model_combo.currentText().strip()
+        nuclear_channel = self._nuclear_channel_combo.currentText().strip()
+        if not nuclear_model or nuclear_model.startswith("("):
+            return []
+        if not nuclear_channel or nuclear_channel.startswith("("):
+            return []
+        return [f"{nuclear_channel}_{nuclear_model}_nuc_labels"]
 
     def _refresh_config_viewer(self) -> None:
         """Refresh the quantification preview viewer shim."""
@@ -663,6 +701,8 @@ class BatchTab(QWidget):
         self._nuclear_settings_widgets.clear()
         self._nuclear_settings_meta.clear()
         if not model_name or model_name.startswith("("):
+            self._refresh_channel_choices()
+            self._refresh_config_viewer()
             return
         model = self._segmentation_backend.get_model(model_name)
         settings = model.list_settings()
@@ -671,17 +711,23 @@ class BatchTab(QWidget):
             item.get("key", item.get("label", "")): item for item in settings
         }
         self._nuclear_settings_values = _defaults_from_settings(settings)
+        self._refresh_channel_choices()
+        self._refresh_config_viewer()
 
     def _update_cyto_settings(self) -> None:
         """Refresh cytoplasmic model settings from the selected model."""
         model_name = self._cyto_model_combo.currentText()
         self._cyto_settings_widgets.clear()
         self._cyto_settings_meta.clear()
+        self._cyto_nuclear_optional = False
+        self._cyto_nuclear_from_labels = False
+        self._cyto_requires_cyto_channel = True
+        self._cyto_supports_nuclear_input = False
         if not model_name or model_name.startswith("("):
-            self._cyto_nuclear_combo.setEnabled(False)
             if hasattr(self, "_cyto_nuclear_label"):
                 self._cyto_nuclear_label.setText("Nuclear channel")
-            self._cyto_nuclear_optional = False
+            self._refresh_channel_choices()
+            self._update_processing_state()
             return
         model = self._segmentation_backend.get_model(model_name)
         settings = model.list_settings()
@@ -691,20 +737,30 @@ class BatchTab(QWidget):
         }
         self._cyto_settings_values = _defaults_from_settings(settings)
         modes = model.cytoplasmic_input_modes()
-        supports_nuclear = "nuclear+cytoplasmic" in modes
-        if supports_nuclear:
+        if modes == ["nuclear"]:
+            if hasattr(self, "_cyto_nuclear_label"):
+                self._cyto_nuclear_label.setText("Nuclear labels layer")
+            self._cyto_nuclear_from_labels = True
+            self._cyto_requires_cyto_channel = False
+            self._cyto_supports_nuclear_input = True
+        elif "nuclear+cytoplasmic" in modes:
             optional = model.cytoplasmic_nuclear_optional()
             suffix = "optional" if optional else "required"
             if hasattr(self, "_cyto_nuclear_label"):
                 self._cyto_nuclear_label.setText(f"Nuclear channel ({suffix})")
-            self._cyto_nuclear_combo.setEnabled(True)
             self._cyto_nuclear_optional = optional
+            self._cyto_supports_nuclear_input = True
         else:
             if hasattr(self, "_cyto_nuclear_label"):
                 self._cyto_nuclear_label.setText("Nuclear channel")
-            self._cyto_nuclear_combo.setEnabled(False)
-            self._cyto_nuclear_optional = False
         self._refresh_channel_choices()
+        self._update_processing_state()
+
+    def _on_nuclear_channel_changed(self, _text: str) -> None:
+        """Refresh dependent combos when the nuclear channel changes."""
+        if self._cyto_nuclear_from_labels:
+            self._refresh_channel_choices()
+        self._refresh_config_viewer()
 
     def _update_spot_settings(self) -> None:
         """Refresh spot detector settings from the selected detector."""
@@ -832,12 +888,18 @@ class BatchTab(QWidget):
         nuclear_enabled = self._nuclear_enabled.isChecked()
         cyto_enabled = self._cyto_enabled.isChecked()
         spot_enabled = self._spots_enabled.isChecked()
+        if self._cyto_nuclear_from_labels:
+            self._refresh_channel_choices()
         self._nuclear_model_combo.setEnabled(nuclear_enabled)
         self._nuclear_channel_combo.setEnabled(nuclear_enabled)
         self._nuclear_settings_button.setEnabled(nuclear_enabled)
         self._cyto_model_combo.setEnabled(cyto_enabled)
-        self._cyto_channel_combo.setEnabled(cyto_enabled)
-        self._cyto_nuclear_combo.setEnabled(cyto_enabled)
+        self._cyto_channel_combo.setEnabled(
+            cyto_enabled and self._cyto_requires_cyto_channel
+        )
+        self._cyto_nuclear_combo.setEnabled(
+            cyto_enabled and self._cyto_supports_nuclear_input
+        )
         self._cyto_settings_button.setEnabled(cyto_enabled)
         self._spot_detector_combo.setEnabled(spot_enabled)
         self._spot_settings_button.setEnabled(spot_enabled)
@@ -886,10 +948,33 @@ class BatchTab(QWidget):
                 spot_detector = None
 
         cyto_model = None
+        cyto_model_obj = None
         if self._cyto_enabled.isChecked() and self._cyto_model_combo.isEnabled():
             cyto_model = self._cyto_model_combo.currentText().strip()
             if cyto_model.startswith("("):
                 cyto_model = None
+            elif cyto_model:
+                cyto_model_obj = self._segmentation_backend.get_model(cyto_model)
+
+        if cyto_model_obj is not None and self._cyto_requires_nuclear(cyto_model_obj):
+            cyto_nuclear_choice = self._cyto_nuclear_combo.currentText().strip()
+            if (
+                not cyto_nuclear_choice
+                or cyto_nuclear_choice == "(none)"
+                or cyto_nuclear_choice == "(no nuclear labels)"
+            ):
+                self._notify("Select the required cytoplasmic nuclear input.")
+                return
+
+            if (
+                cyto_model_obj.cytoplasmic_input_modes() == ["nuclear"]
+                and not nuclear_model
+            ):
+                self._notify(
+                    "Selected cytoplasmic model requires nuclear labels. "
+                    "Enable nuclear segmentation first."
+                )
+                return
 
         quant_features = (
             list(self._quant_tab._feature_configs)
@@ -1008,7 +1093,8 @@ class BatchTab(QWidget):
                 channel=self._cyto_channel_combo.currentText(),
                 nuclear_channel=(
                     ""
-                    if self._cyto_nuclear_combo.currentText().strip() == "(none)"
+                    if self._cyto_nuclear_combo.currentText().strip()
+                    in {"(none)", "(no nuclear labels)"}
                     else self._cyto_nuclear_combo.currentText()
                 ),
                 settings=cyto_settings,
@@ -1057,6 +1143,8 @@ class BatchTab(QWidget):
         if not job.cytoplasmic.nuclear_channel:
             if self._cyto_nuclear_combo.findText("(none)") != -1:
                 self._set_combo_value(self._cyto_nuclear_combo, "(none)")
+            elif self._cyto_nuclear_combo.findText("(no nuclear labels)") != -1:
+                self._set_combo_value(self._cyto_nuclear_combo, "(no nuclear labels)")
         else:
             self._set_combo_value(
                 self._cyto_nuclear_combo, job.cytoplasmic.nuclear_channel
@@ -1082,6 +1170,16 @@ class BatchTab(QWidget):
         self._refresh_spot_channel_choices()
         self._refresh_config_viewer()
 
+    @staticmethod
+    def _cyto_requires_nuclear(model) -> bool:
+        """Return whether the selected cytoplasmic model requires nuclear input."""
+        modes = model.cytoplasmic_input_modes()
+        if modes == ["nuclear"]:
+            return True
+        if "nuclear+cytoplasmic" not in modes:
+            return False
+        return not model.cytoplasmic_nuclear_optional()
+
     def _save_profile(self) -> None:
         """Save the current configuration to a JSON profile."""
         path, _ = QFileDialog.getSaveFileName(

senoquant/tabs/spots/frontend.py

@@ -651,6 +651,9 @@ 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."""
@@ -694,6 +697,57 @@ class SpotsTab(QWidget):
         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.
         

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

@@ -0,0 +1,55 @@
+{
+  "name": "rmp",
+  "description": "RMP spot detector implementation",
+  "version": "0.1.0",
+  "order": 0,
+  "settings": [
+    {
+      "key": "denoising_kernel_length",
+      "label": "Denoising kernel length",
+      "type": "int",
+      "min": 2,
+      "max": 9999,
+      "default": 2,
+      "enabled_by": "enable_denoising"
+    },
+    {
+      "key": "extraction_kernel_length",
+      "label": "Extraction kernel length",
+      "type": "int",
+      "min": 3,
+      "max": 9999,
+      "default": 10
+    },
+    {
+      "key": "angle_spacing",
+      "label": "Angle spacing",
+      "type": "int",
+      "min": 1,
+      "max": 10,
+      "default": 5
+    },
+    {
+      "key": "manual_threshold",
+      "label": "Manual threshold",
+      "type": "float",
+      "decimals": 2,
+      "min": 0.0,
+      "max": 1.0,
+      "default": 0.05,
+      "disabled_by": "auto_threshold"
+    },
+    {
+      "key": "auto_threshold",
+      "label": "Auto threshold",
+      "type": "bool",
+      "default": true
+    },
+    {
+      "key": "enable_denoising",
+      "label": "Enable denoising",
+      "type": "bool",
+      "default": true
+    }
+  ]
+}