TwoPy 0.1.0__py3-none-any.whl

twopy/napari/plotting/export_controls.py

@@ -0,0 +1,209 @@
+"""Qt controls that trigger response-plot exports.
+
+Inputs: a callable that returns the current response export state.
+Outputs: one Export tab with buttons for recording images, ROI overlays, and
+response plots.
+
+This module owns export button wiring only. It keeps the response dock focused
+on live plot state while the pure export functions write the actual figures.
+"""
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from pathlib import Path
+
+from qtpy.QtWidgets import QLabel, QPushButton, QVBoxLayout, QWidget
+
+from twopy.converted import RecordingData
+from twopy.napari.display_paths import format_output_folder
+from twopy.napari.plotting.data import ResponsePlotData
+from twopy.napari.plotting.export import (
+    export_epoch_plots,
+    export_epoch_roi_overlay_plots,
+    export_recording_roi_overlay,
+    export_recording_view,
+    export_roi_view,
+)
+from twopy.napari.text import counted_noun
+
+__all__ = ["ResponseExportState", "create_response_export_tab"]
+
+
+@dataclass(frozen=True)
+class ResponseExportState:
+    """Current napari and response-plot state needed for export actions.
+
+    Inputs: viewer, loaded recording, ROI layer, plot data, visible selections,
+    axis bounds, and output folder.
+    Outputs: immutable state object consumed by export buttons.
+    """
+
+    viewer: object | None
+    recording: RecordingData | None
+    roi_labels_layer: object | None
+    plot_data: ResponsePlotData | None
+    output_dir: Path
+    roi_label_values: tuple[int, ...]
+    roi_colors: tuple[str, ...]
+    epoch_indices: tuple[int, ...]
+    roi_indices: tuple[int, ...]
+    show_sem: bool
+    time_bounds: tuple[float, float]
+    value_bounds: tuple[float, float]
+
+
+def create_response_export_tab(
+    get_state: Callable[[], ResponseExportState],
+) -> QWidget:
+    """Create the response export tab.
+
+    Args:
+        get_state: Callback returning current response and napari state.
+
+    Returns:
+        Qt widget with export buttons and status text.
+    """
+    status_label = QLabel("Exports save beside the recording.")
+    status_label.setWordWrap(True)
+    tab = QWidget()
+    layout = QVBoxLayout()
+    for text, callback in (
+        ("Save recording view", _save_recording_view),
+        ("Save ROI view", _save_roi_view),
+        ("Save recording ROI overlay", _save_recording_roi_overlay),
+        ("Save plots", _save_plots),
+        ("Save plots with ROIs", _save_plots_with_rois),
+    ):
+        layout.addWidget(_button(text, get_state, status_label, callback))
+    layout.addWidget(status_label)
+    layout.addStretch(1)
+    tab.setLayout(layout)
+    return tab
+
+
+def _save_recording_view(state: ResponseExportState) -> tuple[Path, ...] | str:
+    """Export the current movie frame or mean-image fallback."""
+    if state.recording is None:
+        return "No recording loaded."
+    return export_recording_view(
+        viewer=state.viewer,
+        recording=state.recording,
+        output_dir=state.output_dir,
+    )
+
+
+def _save_roi_view(state: ResponseExportState) -> tuple[Path, ...] | str:
+    """Export current ROI contours without a recording image."""
+    if state.recording is None:
+        return "No recording loaded."
+    return export_roi_view(
+        roi_labels_layer=state.roi_labels_layer,
+        recording=state.recording,
+        output_dir=state.output_dir,
+        roi_label_values=state.roi_label_values,
+        roi_colors=state.roi_colors,
+    )
+
+
+def _save_recording_roi_overlay(
+    state: ResponseExportState,
+) -> tuple[Path, ...] | str:
+    """Export current recording image with ROI contours overlaid."""
+    if state.recording is None:
+        return "No recording loaded."
+    return export_recording_roi_overlay(
+        viewer=state.viewer,
+        recording=state.recording,
+        roi_labels_layer=state.roi_labels_layer,
+        output_dir=state.output_dir,
+        roi_label_values=state.roi_label_values,
+        roi_colors=state.roi_colors,
+    )
+
+
+def _save_plots(state: ResponseExportState) -> tuple[Path, ...] | str:
+    """Export each visible epoch response plot."""
+    if state.plot_data is None:
+        return "No responses available."
+    return export_epoch_plots(
+        plot_data=state.plot_data,
+        output_dir=state.output_dir,
+        epoch_indices=state.epoch_indices,
+        roi_indices=state.roi_indices,
+        roi_colors=state.roi_colors,
+        show_sem=state.show_sem,
+        time_bounds=state.time_bounds,
+        value_bounds=state.value_bounds,
+    )
+
+
+def _save_plots_with_rois(state: ResponseExportState) -> tuple[Path, ...] | str:
+    """Export two-column ROI overlay plus response plot figures."""
+    if state.recording is None:
+        return "No recording loaded."
+    if state.plot_data is None:
+        return "No responses available."
+    return export_epoch_roi_overlay_plots(
+        viewer=state.viewer,
+        recording=state.recording,
+        roi_labels_layer=state.roi_labels_layer,
+        plot_data=state.plot_data,
+        output_dir=state.output_dir,
+        epoch_indices=state.epoch_indices,
+        roi_indices=state.roi_indices,
+        roi_label_values=state.roi_label_values,
+        roi_colors=state.roi_colors,
+        show_sem=state.show_sem,
+        time_bounds=state.time_bounds,
+        value_bounds=state.value_bounds,
+    )
+
+
+def _button(
+    text: str,
+    get_state: Callable[[], ResponseExportState],
+    status_label: QLabel,
+    callback: Callable[[ResponseExportState], tuple[Path, ...] | str],
+) -> QPushButton:
+    """Create one export button.
+
+    Args:
+        text: Button label.
+        get_state: Callback returning current export state.
+        status_label: Label updated after the button runs.
+        callback: Export action for this button.
+
+    Returns:
+        Configured Qt button.
+    """
+    button = QPushButton(text)
+
+    def run_export() -> None:
+        """Run the export action and show a short status."""
+        state = get_state()
+        result = callback(state)
+        status_label.setText(_export_status(result, state.recording))
+
+    button.clicked.connect(run_export)
+    return button
+
+
+def _export_status(
+    result: tuple[Path, ...] | str,
+    recording: RecordingData | None,
+) -> str:
+    """Return a compact export status message.
+
+    Args:
+        result: Either an error/status string or written files.
+        recording: Optional selected recording for compact folder display.
+
+    Returns:
+        User-facing status string.
+    """
+    if isinstance(result, str):
+        return result
+    if len(result) == 0:
+        return "No files exported."
+    folder = format_output_folder(result[0].parent, recording)
+    return f"Saved {counted_noun(len(result), 'file')} to {folder}"

twopy/napari/plotting/label_visibility.py

@@ -0,0 +1,260 @@
+"""Synchronize plot ROI visibility with the napari Labels overlay.
+
+Inputs: the current napari Labels layer, ROI labels, ROI visibility state, and
+ROI colors.
+Outputs: a Labels-layer colormap where deselected ROIs are dimmed.
+
+This module only changes how labels are displayed. It never edits the label
+image, so hiding an ROI in the plot options cannot delete ROI data.
+"""
+
+from collections.abc import Mapping
+from typing import Any, Protocol, cast
+
+from qtpy.QtGui import QColor
+
+__all__ = [
+    "apply_roi_visibility_to_labels_layer",
+    "roi_label_value_from_label",
+    "roi_label_values_from_labels",
+]
+
+_LABEL_COLOR_LOOKAHEAD = 4096
+_BASE_LABEL_COLORMAP_METADATA_KEY = "twopy_base_label_colormap"
+_DESELECTED_ROI_ALPHA = 0.2
+type VisibilityKey = int | str
+type VisibilityState = Mapping[int, bool] | Mapping[str, bool]
+
+
+class _LabelsLayerWithColormap(Protocol):
+    """Small protocol for napari Labels layers with settable colormaps."""
+
+    colormap: object
+    metadata: dict[str, object]
+
+
+class _LabelColormapLike(Protocol):
+    """Small protocol for napari label colormaps used for color sampling."""
+
+    colors: object
+    seed: object
+    background_value: object
+
+
+def apply_roi_visibility_to_labels_layer(
+    layer: object | None,
+    *,
+    roi_labels: tuple[str, ...],
+    visibility: VisibilityState,
+    colors: tuple[QColor, ...],
+    keys: tuple[VisibilityKey, ...] | None = None,
+) -> None:
+    """Apply ROI visibility state to the napari Labels layer display.
+
+    Args:
+        layer: Current napari Labels layer, if available.
+        roi_labels: ROI names in analysis/plot order.
+        visibility: Visibility by ROI name, or by ``keys`` when keys are
+            provided.
+        colors: ROI colors in the same order as ``roi_labels``.
+        keys: Optional stable visibility keys matching ``roi_labels``.
+
+    Returns:
+        None.
+
+    Deselected ROIs keep their label pixels in ``layer.data``; only their
+    display alpha is reduced. Future labels stay drawable because the direct
+    colormap contains napari-style colors for a broad range of label values
+    instead of a single fallback color.
+    """
+    if layer is None or not hasattr(layer, "colormap"):
+        return
+
+    try:
+        from napari.utils.colormaps import direct_colormap
+    except ImportError:
+        return
+
+    labels_layer = cast(_LabelsLayerWithColormap, layer)
+    visibility_lookup = dict(visibility.items())
+    color_dict = _visible_label_color_dict(
+        labels_layer,
+        roi_labels=roi_labels,
+    )
+    for roi_index, roi_label in enumerate(roi_labels):
+        label_value = roi_label_value_from_label(
+            roi_label,
+            fallback=roi_index + 1,
+        )
+        key = (
+            keys[roi_index] if keys is not None and roi_index < len(keys) else roi_label
+        )
+        color = colors[roi_index] if roi_index < len(colors) else QColor("#4cc9f0")
+        color_dict[label_value] = _qcolor_rgba(color, visibility_lookup.get(key, True))
+
+    labels_layer.colormap = direct_colormap(color_dict)
+
+
+def roi_label_value_from_label(label: str, *, fallback: int) -> int:
+    """Return the napari integer label represented by one ROI label.
+
+    Args:
+        label: ROI label from analysis output, usually ``roi_0001``.
+        fallback: One-based ROI position used when the label has no numeric
+            suffix.
+
+    Returns:
+        Positive integer label value for the napari Labels layer.
+
+    napari lets users draw label ``10`` without drawing labels ``1`` through
+    ``9``. ``make_roi_set_from_label_image`` preserves that value in labels like
+    ``roi_0010``, so visibility needs to target label ``10`` instead of the
+    first plotted ROI position.
+    """
+    suffix = label.rsplit("_", maxsplit=1)[-1]
+    if suffix.isdecimal():
+        return int(suffix)
+    return fallback
+
+
+def roi_label_values_from_labels(roi_labels: tuple[str, ...]) -> tuple[int, ...]:
+    """Return napari integer Labels values for plot ROI labels.
+
+    Args:
+        roi_labels: ROI labels in plot order.
+
+    Returns:
+        Integer Labels-layer values in the same order.
+    """
+    return tuple(
+        roi_label_value_from_label(roi_label, fallback=index + 1)
+        for index, roi_label in enumerate(roi_labels)
+    )
+
+
+def _qcolor_rgba(color: QColor, visible: bool) -> tuple[float, float, float, float]:
+    """Return a normalized RGBA tuple for one ROI label.
+
+    Args:
+        color: ROI color.
+        visible: Whether the ROI should be fully visible in the Labels overlay.
+
+    Returns:
+        RGBA tuple in napari's expected ``0`` to ``1`` float range.
+    """
+    return (
+        color.redF(),
+        color.greenF(),
+        color.blueF(),
+        1.0 if visible else _DESELECTED_ROI_ALPHA,
+    )
+
+
+def _visible_label_color_dict(
+    layer: _LabelsLayerWithColormap,
+    *,
+    roi_labels: tuple[str, ...],
+) -> dict[int | None, object]:
+    """Return visible colors for known and future Labels values.
+
+    Args:
+        layer: napari Labels layer.
+        roi_labels: ROI names in analysis/plot order.
+
+    Returns:
+        Mapping from label values to RGBA colors for napari's direct colormap.
+    """
+    color_count = max(
+        _LABEL_COLOR_LOOKAHEAD,
+        _max_roi_label_value(roi_labels) + 512,
+    )
+    color_dict: dict[int | None, object] = {0: "transparent"}
+    for label_value in range(1, color_count + 1):
+        color_dict[label_value] = _base_label_rgba(layer, label_value)
+    color_dict[None] = color_dict[color_count]
+    return color_dict
+
+
+def _max_roi_label_value(roi_labels: tuple[str, ...]) -> int:
+    """Return the largest integer label represented by ROI labels.
+
+    Args:
+        roi_labels: ROI names in analysis/plot order.
+
+    Returns:
+        Maximum positive Labels value, or ``0`` when there are no ROIs.
+    """
+    if len(roi_labels) == 0:
+        return 0
+    return max(
+        roi_label_value_from_label(roi_label, fallback=index + 1)
+        for index, roi_label in enumerate(roi_labels)
+    )
+
+
+def _base_label_rgba(
+    layer: _LabelsLayerWithColormap,
+    label_value: int,
+) -> tuple[float, float, float, float]:
+    """Return napari's cyclic label color for one label value.
+
+    Args:
+        layer: napari Labels layer.
+        label_value: Positive integer label value.
+
+    Returns:
+        RGBA tuple in ``0`` to ``1`` float range.
+    """
+    try:
+        from napari.utils.colormaps import label_colormap
+    except ImportError:
+        return _qcolor_rgba(QColor("#4cc9f0"), True)
+
+    params = _base_label_colormap_params(layer)
+    colormap = label_colormap(
+        num_colors=params["num_colors"],
+        seed=params["seed"],
+        background_value=params["background_value"],
+    )
+    rgba = colormap.map(label_value)
+    return (
+        float(rgba[0]),
+        float(rgba[1]),
+        float(rgba[2]),
+        float(rgba[3]),
+    )
+
+
+def _base_label_colormap_params(
+    layer: _LabelsLayerWithColormap,
+) -> dict[str, int | float]:
+    """Return stable cyclic-colormap parameters for one Labels layer.
+
+    Args:
+        layer: napari Labels layer.
+
+    Returns:
+        Plain parameters for reconstructing napari's cyclic label colormap.
+
+    The first call records the original cyclic colormap. Later calls may see a
+    direct visibility colormap, so reading from metadata preserves the original
+    color cycle while users toggle ROI visibility.
+    """
+    stored = layer.metadata.get(_BASE_LABEL_COLORMAP_METADATA_KEY)
+    if isinstance(stored, dict):
+        stored_params = cast(dict[str, object], stored)
+        return {
+            "num_colors": int(cast(Any, stored_params["num_colors"])),
+            "seed": float(cast(Any, stored_params["seed"])),
+            "background_value": int(cast(Any, stored_params["background_value"])),
+        }
+
+    colormap = cast(_LabelColormapLike, layer.colormap)
+    colors = getattr(colormap, "colors", ())
+    params = {
+        "num_colors": max(len(colors) - 1, 1),
+        "seed": float(getattr(colormap, "seed", 0.5)),
+        "background_value": int(getattr(colormap, "background_value", 0)),
+    }
+    layer.metadata[_BASE_LABEL_COLORMAP_METADATA_KEY] = params
+    return params