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

senoquant/__init__.py

@@ -1,6 +1,10 @@
 """SenoQuant napari plugin package."""
 
-from ._widget import SenoQuantWidget
+try:
+    from importlib.metadata import version
+    __version__ = version("senoquant")
+except Exception:
+    __version__ = "1.0.0b3"  # Fallback for development
 
-__version__ = "1.0.0b2"
+from ._widget import SenoQuantWidget
 __all__ = ["SenoQuantWidget"]

senoquant/_reader.py

@@ -1,4 +1,4 @@
-"""Napari reader entrypoint for SenoQuant."""
+"""napari reader entrypoint for SenoQuant."""
 
 from __future__ import annotations
 

senoquant/reader/core.py

@@ -75,7 +75,7 @@ def _read_senoquant(path: str) -> Iterable[tuple]:
     Returns
     -------
     iterable of tuple
-        Napari layer tuples of the form ``(data, metadata, layer_type)``.
+        napari layer tuples of the form ``(data, metadata, layer_type)``.
 
     Notes
     -----
@@ -91,25 +91,208 @@ def _read_senoquant(path: str) -> Iterable[tuple]:
 
     base_name = Path(path).name
     image = _open_bioimage(path)
-    layers: list[tuple] = []
-    colormap_cycle = _colormap_cycle()
-    scenes = image.scenes
-
-    for scene_idx, scene_id in enumerate(scenes):
-        image.set_scene(scene_id)
-        layers.extend(
-            _iter_channel_layers(
-                image,
-                base_name=base_name,
-                scene_id=scene_id,
-                scene_idx=scene_idx,
-                total_scenes=len(scenes),
-                path=path,
-                colormap_cycle=colormap_cycle,
+    try:
+        layers: list[tuple] = []
+        colormap_cycle = _colormap_cycle()
+        scenes = list(getattr(image, "scenes", []) or [])
+        selected_scene_indices = _select_scene_indices(path, scenes)
+        if not selected_scene_indices:
+            return layers
+
+        for scene_idx in selected_scene_indices:
+            scene_id = scenes[scene_idx]
+            image.set_scene(scene_id)
+            layers.extend(
+                _iter_channel_layers(
+                    image,
+                    base_name=base_name,
+                    scene_id=scene_id,
+                    scene_idx=scene_idx,
+                    total_scenes=len(scenes),
+                    path=path,
+                    colormap_cycle=colormap_cycle,
+                )
             )
+
+        return layers
+    finally:
+        if hasattr(image, "close"):
+            try:
+                image.close()
+            except Exception:
+                pass
+
+
+def _select_scene_indices(path: str, scenes: list[str]) -> list[int]:
+    """Return scene indices selected by the user for loading."""
+    if not scenes:
+        return []
+    if len(scenes) == 1:
+        return [0]
+
+    selected = _prompt_scene_selection(path, scenes)
+    if selected is None:
+        return []
+    return selected
+
+
+def _prompt_scene_selection(path: str, scenes: list[str]) -> list[int] | None:
+    """Show a scene-selection dialog and return selected indices.
+
+    Returns
+    -------
+    list[int] or None
+        Selected scene indices. Returns ``None`` when the dialog is cancelled.
+        If Qt is not available, all scenes are selected.
+    """
+    try:
+        from qtpy.QtCore import Qt
+        from qtpy.QtWidgets import (
+            QApplication,
+            QDialog,
+            QDialogButtonBox,
+            QHBoxLayout,
+            QLabel,
+            QListWidget,
+            QListWidgetItem,
+            QMessageBox,
+            QPushButton,
+            QVBoxLayout,
+        )
+    except Exception:
+        return list(range(len(scenes)))
+
+    app = QApplication.instance()
+    if app is None:
+        return list(range(len(scenes)))
+
+    dialog = QDialog(_napari_dialog_parent(app))
+    dialog.setWindowTitle("Select scenes to load")
+    dialog.setMinimumWidth(520)
+    _apply_napari_dialog_theme(dialog, app)
+
+    layout = QVBoxLayout(dialog)
+    layout.addWidget(QLabel(f"File: {Path(path).name}"))
+    layout.addWidget(QLabel(f"Select scenes to load ({len(scenes)} total):"))
+
+    scene_list = QListWidget(dialog)
+    for index, scene_id in enumerate(scenes):
+        scene_name = str(scene_id).strip() or f"Scene {index}"
+        item = QListWidgetItem(f"{index}: {scene_name}")
+        item.setData(Qt.UserRole, index)
+        item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
+        item.setCheckState(Qt.Checked)
+        scene_list.addItem(item)
+    scene_list.setMinimumHeight(300)
+    layout.addWidget(scene_list)
+
+    controls = QHBoxLayout()
+    select_all_button = QPushButton("Select all")
+    clear_all_button = QPushButton("Clear all")
+    controls.addWidget(select_all_button)
+    controls.addWidget(clear_all_button)
+    controls.addStretch(1)
+    layout.addLayout(controls)
+
+    select_all_button.clicked.connect(
+        lambda: _set_scene_checks(scene_list, Qt.Checked)
+    )
+    clear_all_button.clicked.connect(lambda: _set_scene_checks(scene_list, Qt.Unchecked))
+
+    buttons = QDialogButtonBox(
+        QDialogButtonBox.Ok | QDialogButtonBox.Cancel, parent=dialog
+    )
+    layout.addWidget(buttons)
+
+    def _accept_if_valid() -> None:
+        checked = _checked_scene_indices(scene_list)
+        if checked:
+            dialog.accept()
+            return
+        QMessageBox.warning(
+            dialog,
+            "No scenes selected",
+            "Select at least one scene to load.",
         )
 
-    return layers
+    buttons.accepted.connect(_accept_if_valid)
+    buttons.rejected.connect(dialog.reject)
+
+    if dialog.exec() != QDialog.Accepted:
+        return None
+    return _checked_scene_indices(scene_list)
+
+
+def _napari_dialog_parent(app):
+    """Return a good parent window for napari-linked dialogs."""
+    try:
+        import napari
+
+        viewer = napari.current_viewer()
+    except Exception:
+        viewer = None
+    if viewer is not None:
+        window = getattr(viewer, "window", None)
+        qt_window = getattr(window, "_qt_window", None)
+        if qt_window is not None:
+            return qt_window
+    return app.activeWindow()
+
+
+def _apply_napari_dialog_theme(dialog, app) -> None:
+    """Apply napari/app stylesheet so popup theming is consistent."""
+    stylesheet = ""
+    try:
+        import napari
+
+        viewer = napari.current_viewer()
+        theme_id = getattr(viewer, "theme", None) if viewer is not None else None
+        if theme_id:
+            try:
+                from napari.qt import get_stylesheet
+
+                stylesheet = str(get_stylesheet(theme_id) or "")
+            except Exception:
+                stylesheet = ""
+    except Exception:
+        stylesheet = ""
+
+    if not stylesheet:
+        try:
+            stylesheet = str(app.styleSheet() or "")
+        except Exception:
+            stylesheet = ""
+    if not stylesheet:
+        try:
+            parent = dialog.parentWidget()
+            stylesheet = str(parent.styleSheet() if parent is not None else "")
+        except Exception:
+            stylesheet = ""
+
+    if stylesheet:
+        dialog.setStyleSheet(stylesheet)
+
+
+def _set_scene_checks(scene_list, state) -> None:
+    """Set check state for all scene list items."""
+    for row in range(scene_list.count()):
+        item = scene_list.item(row)
+        if item is not None:
+            item.setCheckState(state)
+
+
+def _checked_scene_indices(scene_list) -> list[int]:
+    """Return checked scene indices from a QListWidget."""
+    from qtpy.QtCore import Qt
+
+    selected: list[int] = []
+    for row in range(scene_list.count()):
+        item = scene_list.item(row)
+        if item is None:
+            continue
+        if item.checkState() == Qt.Checked:
+            selected.append(int(item.data(Qt.UserRole)))
+    return selected
 
 
 def _open_bioimage(path: str):
@@ -304,7 +487,7 @@ def _iter_channel_layers(
     Returns
     -------
     list of tuple
-        Napari layer tuples for each channel.
+        napari layer tuples for each channel.
     """
     dims = getattr(image, "dims", None)
     axes_present = _axes_present(image)

senoquant/tabs/batch/backend.py

@@ -343,7 +343,9 @@ class BatchBackend:
                                 output_format,
                             )
                             labels_data[label_name] = masks
-                            labels_meta[label_name] = metadata
+                            labels_meta[label_name] = _with_task_metadata(
+                                metadata, "nuclear"
+                            )
                             item_result.outputs[label_name] = out_path
 
                     if cyto_model:
@@ -393,7 +395,9 @@ class BatchBackend:
                                 output_format,
                             )
                             labels_data[label_name] = masks
-                            labels_meta[label_name] = cyto_meta
+                            labels_meta[label_name] = _with_task_metadata(
+                                cyto_meta, "cytoplasmic"
+                            )
                             item_result.outputs[label_name] = out_path
 
                     if spot_detector:
@@ -434,7 +438,9 @@ class BatchBackend:
                                 output_format,
                             )
                             labels_data[label_name] = mask
-                            labels_meta[label_name] = spot_meta
+                            labels_meta[label_name] = _with_task_metadata(
+                                spot_meta, "spots"
+                            )
                             item_result.outputs[label_name] = out_path
 
                     if quantification_features:
@@ -575,6 +581,15 @@ def _resolve_output_dir(
     return output_dir
 
 
+def _with_task_metadata(metadata: dict | None, task: str) -> dict:
+    """Return a metadata copy with task type attached."""
+    payload: dict[str, object] = {}
+    if isinstance(metadata, dict):
+        payload.update(metadata)
+    payload["task"] = task
+    return payload
+
+
 def _build_viewer_for_quantification(
     path: Path,
     scene_id: str | None,

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
@@ -639,18 +639,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:

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
         -------