senoquant 1.0.0b2__py3-none-any.whl → 1.0.0b4__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.0b4"  # 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/_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/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/__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
@@ -343,40 +352,67 @@ 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:
-                        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_nuclear_layer = Image(
-                                nuclear_image, "nuclear", nuclear_meta
+                            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
+                                )
+                                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,
                         )
@@ -393,7 +429,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 +472,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 +615,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,