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

senoquant/tabs/batch/frontend.py

@@ -94,7 +94,7 @@ class BatchTab(QWidget):
         backend : BatchBackend or None, optional
             Backend instance used to execute batch runs.
         napari_viewer : object or None, optional
-            Napari viewer instance for populating layer choices.
+            napari viewer instance for populating layer choices.
         """
         super().__init__()
         self._viewer = napari_viewer
@@ -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."""
@@ -639,18 +677,22 @@ class BatchTab(QWidget):
             nuclear_channel = self._nuclear_channel_combo.currentText()
             if nuclear_model and nuclear_channel and not nuclear_model.startswith("("):
                 label_name = f"{nuclear_channel}_{nuclear_model}_nuc_labels"
-                layers.append(Labels(None, label_name))
+                layers.append(Labels(None, label_name, metadata={"task": "nuclear"}))
         if getattr(self, "_cyto_enabled", None) is not None and self._cyto_enabled.isChecked():
             cyto_model = self._cyto_model_combo.currentText()
             cyto_channel = self._cyto_channel_combo.currentText()
             if cyto_model and cyto_channel and not cyto_model.startswith("("):
                 label_name = f"{cyto_channel}_{cyto_model}_cyto_labels"
-                layers.append(Labels(None, label_name))
+                layers.append(
+                    Labels(None, label_name, metadata={"task": "cytoplasmic"})
+                )
         if getattr(self, "_spots_enabled", None) is not None and self._spots_enabled.isChecked():
             spot_detector = self._spot_detector_combo.currentText()
             if spot_detector and not spot_detector.startswith("("):
                 for label_name in _spot_label_names(self._spot_channel_rows, spot_detector):
-                    layers.append(Labels(None, label_name))
+                    layers.append(
+                        Labels(None, label_name, metadata={"task": "spots"})
+                    )
         self._config_viewer.set_layers(layers)
 
     def _update_nuclear_settings(self) -> None:
@@ -659,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()
@@ -667,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()
@@ -687,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."""
@@ -828,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)
@@ -882,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)
@@ -1004,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,
@@ -1053,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
@@ -1078,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/quantification/features/marker/dialog.py

@@ -193,28 +193,48 @@ class MarkerChannelsDialog(QDialog):
             return
         for layer in viewer.layers:
             if layer.__class__.__name__ == "Labels":
-                layer_name = layer.name
                 # Only show cellular labels (nuclear/cytoplasmic), exclude spot labels
-                if self._is_cellular_label(layer_name):
-                    combo.addItem(layer_name)
+                if self._is_cellular_label(layer):
+                    combo.addItem(layer.name)
         if current:
             index = combo.findText(current)
             if index != -1:
                 combo.setCurrentIndex(index)
 
-    def _is_cellular_label(self, layer_name: str) -> bool:
+    def _layer_task(self, layer: object) -> str | None:
+        """Return normalized segmentation task from layer metadata."""
+        metadata = getattr(layer, "metadata", None)
+        if not isinstance(metadata, dict):
+            return None
+        task = metadata.get("task")
+        if not isinstance(task, str):
+            return None
+        normalized = task.strip().lower()
+        return normalized or None
+
+    def _is_cellular_label(self, layer: object | str) -> bool:
         """Check if a label layer is a cellular segmentation.
 
         Parameters
         ----------
-        layer_name : str
-            Name of the labels layer.
+        layer : object or str
+            Labels layer object or labels layer name.
 
         Returns
         -------
         bool
             True if the layer is a cellular label (nuclear or cytoplasmic).
         """
+        if isinstance(layer, str):
+            layer_name = layer
+            task = None
+        else:
+            layer_name = str(getattr(layer, "name", ""))
+            task = self._layer_task(layer)
+        if task in {"nuclear", "cytoplasmic"}:
+            return True
+        if task is not None:
+            return False
         return layer_name.endswith("_nuc_labels") or layer_name.endswith("_cyto_labels")
 
     def _refresh_image_combo(self, combo: QComboBox) -> None:

senoquant/tabs/quantification/features/marker/export.py

@@ -41,7 +41,7 @@ def export_marker(
     temp_dir : Path
         Temporary directory where outputs should be written.
     viewer : object, optional
-        Napari viewer instance used to resolve layers by name.
+        napari viewer instance used to resolve layers by name.
     export_format : str, optional
         File format for exports (``"csv"`` or ``"xlsx"``).
     enable_thresholds : bool, optional
@@ -76,6 +76,23 @@ def export_marker(
         if metadata_path is not None:
             outputs.append(metadata_path)
 
+    all_segmentations: dict[str, tuple[np.ndarray, np.ndarray]] = {}
+    for segmentation in data.segmentations:
+        seg_name = segmentation.label.strip()
+        if not seg_name:
+            continue
+        seg_layer = _find_layer(viewer, seg_name, "Labels")
+        if seg_layer is None:
+            continue
+        seg_labels = layer_data_asarray(seg_layer)
+        if seg_labels.size == 0:
+            continue
+        seg_label_ids, _seg_centroids = _compute_centroids(seg_labels)
+        if seg_label_ids.size == 0:
+            continue
+        all_segmentations[seg_name] = (seg_labels, seg_label_ids)
+    cross_map = _build_cross_segmentation_map(all_segmentations)
+
     for index, segmentation in enumerate(data.segmentations, start=0):
         label_name = segmentation.label.strip()
         if not label_name:
@@ -103,7 +120,7 @@ def export_marker(
                     break
         rows = _initialize_rows(label_ids, centroids, pixel_sizes)
         _add_roi_columns(rows, labels, label_ids, viewer, data.rois, label_name)
-        morph_columns = add_morphology_columns(
+        _morph_columns = add_morphology_columns(
             rows, labels, label_ids, pixel_sizes
         )
         
@@ -115,11 +132,12 @@ def export_marker(
                 metadata = getattr(first_channel_layer, "metadata", {})
                 file_path = metadata.get("path")
         
-        # Determine segmentation type from label name or config
-        seg_type = getattr(segmentation, "task", "nuclear")
-        ref_columns = _add_reference_columns(
+        # Determine segmentation type from labels metadata with suffix fallback.
+        seg_type = _segmentation_type_from_layer(labels_layer, label_name)
+        _ref_columns = _add_reference_columns(
             rows, labels, label_ids, file_path, seg_type
         )
+        _add_cross_reference_column(rows, label_name, label_ids, cross_map)
         
         header = list(rows[0].keys()) if rows else []
 
@@ -207,7 +225,7 @@ def _find_layer(viewer, name: str, layer_type: str):
     Parameters
     ----------
     viewer : object
-        Napari viewer instance containing layers.
+        napari viewer instance containing layers.
     name : str
         Layer name to locate.
     layer_type : str
@@ -224,6 +242,40 @@ def _find_layer(viewer, name: str, layer_type: str):
     return None
 
 
+def _segmentation_type_from_layer(layer: object, label_name: str) -> str:
+    """Return segmentation type from layer metadata or legacy suffixes.
+
+    Parameters
+    ----------
+    layer : object
+        Labels layer object.
+    label_name : str
+        Labels layer name used for fallback suffix parsing.
+
+    Returns
+    -------
+    str
+        Segmentation type ("nuclear" or "cytoplasmic").
+
+    Notes
+    -----
+    Metadata value ``metadata["task"]`` is authoritative when valid.
+    Legacy layer-name suffixes are used as fallback for older layers.
+    """
+    metadata = getattr(layer, "metadata", None)
+    if isinstance(metadata, dict):
+        task = metadata.get("task")
+        if isinstance(task, str):
+            normalized = task.strip().lower()
+            if normalized in {"nuclear", "cytoplasmic"}:
+                return normalized
+    if label_name.endswith("_cyto_labels"):
+        return "cytoplasmic"
+    if label_name.endswith("_nuc_labels"):
+        return "nuclear"
+    return "nuclear"
+
+
 def _compute_centroids(labels: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
     """Compute centroid coordinates for each non-zero label.
 
@@ -299,7 +351,7 @@ def _pixel_volume(layer, ndim: int) -> float:
     Parameters
     ----------
     layer : object
-        Napari image layer providing metadata.
+        napari image layer providing metadata.
     ndim : int
         Dimensionality of the image data.
 
@@ -348,7 +400,7 @@ def _pixel_sizes(layer, ndim: int) -> np.ndarray | None:
     Parameters
     ----------
     layer : object
-        Napari image layer providing metadata.
+        napari image layer providing metadata.
     ndim : int
         Dimensionality of the image data.
 
@@ -429,7 +481,7 @@ def _add_roi_columns(
     label_ids : numpy.ndarray
         Label ids corresponding to the output rows.
     viewer : object or None
-        Napari viewer used to resolve shapes layers.
+        napari viewer used to resolve shapes layers.
     rois : sequence of ROIConfig
         ROI configuration entries to evaluate.
     label_name : str
@@ -480,7 +532,7 @@ def _shapes_layer_mask(
     Parameters
     ----------
     layer : object
-        Napari shapes layer instance.
+        napari shapes layer instance.
     shape : tuple of int
         Target mask shape matching the labels array.
 
@@ -776,25 +828,46 @@ def _build_cross_segmentation_map(
     -----
     This function identifies which labels from different segmentations
     overlap spatially, enabling cross-referencing between tables.
+    The resulting mapping is bidirectional: if ``A:1`` overlaps ``B:2``,
+    both keys receive a reference to the other.
     """
     cross_map: dict[tuple[str, int], list[tuple[str, int]]] = {}
+    valid_ids: dict[str, set[int]] = {}
+
+    for seg_name, (_labels, label_ids) in all_segmentations.items():
+        ids = {int(label_id) for label_id in np.asarray(label_ids, dtype=int)}
+        valid_ids[seg_name] = ids
+        for label_id in ids:
+            cross_map[(seg_name, label_id)] = []
 
     seg_names = list(all_segmentations.keys())
     for i, seg1_name in enumerate(seg_names):
-        labels1, label_ids1 = all_segmentations[seg1_name]
-        for label_id1 in label_ids1:
-            cross_map[(seg1_name, int(label_id1))] = []
-            # Check overlaps with all other segmentations
-            for seg2_name in seg_names[i + 1 :]:
-                labels2, _label_ids2 = all_segmentations[seg2_name]
-                # Find which labels in seg2 overlap with label_id1
-                mask1 = labels1 == label_id1
-                overlapping_labels2 = np.unique(labels2[mask1])
-                overlapping_labels2 = overlapping_labels2[overlapping_labels2 > 0]
-                for label_id2 in overlapping_labels2:
-                    cross_map[(seg1_name, int(label_id1))].append(
-                        (seg2_name, int(label_id2)),
-                    )
+        labels1, _label_ids1 = all_segmentations[seg1_name]
+        # Check overlaps with all other segmentations.
+        for seg2_name in seg_names[i + 1 :]:
+            labels2, _label_ids2 = all_segmentations[seg2_name]
+            if labels1.shape != labels2.shape:
+                warnings.warn(
+                    "Marker export: segmentation shape mismatch for "
+                    f"'{seg1_name}' vs '{seg2_name}'. "
+                    "Skipping cross-segmentation overlap mapping for this pair.",
+                    RuntimeWarning,
+                )
+                continue
+
+            mask = (labels1 > 0) & (labels2 > 0)
+            if not np.any(mask):
+                continue
+
+            overlap_pairs = np.column_stack((labels1[mask], labels2[mask]))
+            unique_pairs = np.unique(overlap_pairs, axis=0)
+            for label_id1, label_id2 in unique_pairs:
+                id1 = int(label_id1)
+                id2 = int(label_id2)
+                if id1 not in valid_ids[seg1_name] or id2 not in valid_ids[seg2_name]:
+                    continue
+                cross_map[(seg1_name, id1)].append((seg2_name, id2))
+                cross_map[(seg2_name, id2)].append((seg1_name, id1))
 
     return cross_map
 

senoquant/tabs/quantification/features/marker/rows.py

@@ -593,7 +593,7 @@ class MarkerChannelRow(QGroupBox):
         slider : QWidget
             Range slider widget.
         layer : object
-            Napari image layer providing intensity bounds.
+            napari image layer providing intensity bounds.
         min_spin : QDoubleSpinBox or None
             Spin box that displays the minimum threshold value.
         max_spin : QDoubleSpinBox or None
@@ -628,7 +628,7 @@ class MarkerChannelRow(QGroupBox):
         Parameters
         ----------
         layer : object
-            Napari image layer providing contrast bounds and data.
+            napari image layer providing contrast bounds and data.
 
         Returns
         -------

senoquant/tabs/quantification/features/spots/dialog.py

@@ -216,45 +216,75 @@ class SpotsChannelsDialog(QDialog):
             return
         for layer in viewer.layers:
             if layer.__class__.__name__ == "Labels":
-                layer_name = layer.name
                 # Filter based on label type
-                if filter_type == "cellular" and self._is_cellular_label(layer_name):
-                    combo.addItem(layer_name)
-                elif filter_type == "spots" and self._is_spot_label(layer_name):
-                    combo.addItem(layer_name)
+                if filter_type == "cellular" and self._is_cellular_label(layer):
+                    combo.addItem(layer.name)
+                elif filter_type == "spots" and self._is_spot_label(layer):
+                    combo.addItem(layer.name)
         if current:
             index = combo.findText(current)
             if index != -1:
                 combo.setCurrentIndex(index)
 
-    def _is_cellular_label(self, layer_name: str) -> bool:
+    def _layer_task(self, layer: object) -> str | None:
+        """Return normalized segmentation task from layer metadata."""
+        metadata = getattr(layer, "metadata", None)
+        if not isinstance(metadata, dict):
+            return None
+        task = metadata.get("task")
+        if not isinstance(task, str):
+            return None
+        normalized = task.strip().lower()
+        return normalized or None
+
+    def _is_cellular_label(self, layer: object | str) -> bool:
         """Check if a label layer is a cellular segmentation.
 
         Parameters
         ----------
-        layer_name : str
-            Name of the labels layer.
+        layer : object or str
+            Labels layer object or labels layer name.
 
         Returns
         -------
         bool
             True if the layer is a cellular label (nuclear or cytoplasmic).
         """
+        if isinstance(layer, str):
+            layer_name = layer
+            task = None
+        else:
+            layer_name = str(getattr(layer, "name", ""))
+            task = self._layer_task(layer)
+        if task in {"nuclear", "cytoplasmic"}:
+            return True
+        if task is not None:
+            return False
         return layer_name.endswith("_nuc_labels") or layer_name.endswith("_cyto_labels")
 
-    def _is_spot_label(self, layer_name: str) -> bool:
+    def _is_spot_label(self, layer: object | str) -> bool:
         """Check if a label layer is a spot segmentation.
 
         Parameters
         ----------
-        layer_name : str
-            Name of the labels layer.
+        layer : object or str
+            Labels layer object or labels layer name.
 
         Returns
         -------
         bool
             True if the layer is a spot label.
         """
+        if isinstance(layer, str):
+            layer_name = layer
+            task = None
+        else:
+            layer_name = str(getattr(layer, "name", ""))
+            task = self._layer_task(layer)
+        if task == "spots":
+            return True
+        if task is not None:
+            return False
         return layer_name.endswith("_spot_labels")
 
     def _refresh_image_combo(self, combo: QComboBox) -> None: