senoquant 1.0.0b1__py3-none-any.whl

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

@@ -0,0 +1,112 @@
+"""Spots feature UI."""
+
+from pathlib import Path
+
+from qtpy.QtWidgets import QCheckBox, QDialog, QPushButton
+
+from ..base import SenoQuantFeature
+from ..roi import ROISection
+from .config import SpotsFeatureData
+from .dialog import SpotsChannelsDialog
+from .export import export_spots
+
+
+class SpotsFeature(SenoQuantFeature):
+    """Spots feature controls."""
+
+    feature_type = "Spots"
+    order = 20
+
+    def build(self) -> None:
+        """Build the spots feature UI."""
+        self._build_channels_section()
+        data = self._state.data
+        if getattr(self._tab, "_enable_rois", True):
+            if isinstance(data, SpotsFeatureData):
+                roi_section = ROISection(self._tab, self._context, data.rois)
+            else:
+                roi_section = ROISection(self._tab, self._context, [])
+            roi_section.build()
+            self._ui["roi_section"] = roi_section
+
+    def on_features_changed(self, configs: list) -> None:
+        """Update ROI titles when feature ordering changes.
+
+        Parameters
+        ----------
+        configs : list of FeatureUIContext
+            Current feature contexts.
+        """
+        roi_section = self._ui.get("roi_section")
+        if roi_section is not None:
+            roi_section.update_titles()
+
+    def _build_channels_section(self) -> None:
+        """Build the channels button that opens the popup dialog."""
+        left_dynamic_layout = self._context.left_dynamic_layout
+        button = QPushButton("Add channels")
+        button.clicked.connect(self._open_channels_dialog)
+        left_dynamic_layout.addWidget(button)
+        data = self._state.data
+        checkbox = QCheckBox("Export colocalization")
+        checkbox.setChecked(
+            isinstance(data, SpotsFeatureData) and data.export_colocalization
+        )
+        checkbox.toggled.connect(self._set_export_colocalization)
+        left_dynamic_layout.addWidget(checkbox)
+        self._ui["channels_button"] = button
+        self._ui["colocalization_checkbox"] = checkbox
+        self._update_channels_button_label()
+
+    def _set_export_colocalization(self, checked: bool) -> None:
+        """Store colocalization export preference."""
+        data = self._state.data
+        if not isinstance(data, SpotsFeatureData):
+            return
+        data.export_colocalization = checked
+
+    def _open_channels_dialog(self) -> None:
+        """Open the channels configuration dialog."""
+        dialog = self._ui.get("channels_dialog")
+        if dialog is None or not isinstance(dialog, QDialog):
+            dialog = SpotsChannelsDialog(self)
+            dialog.accepted.connect(self._update_channels_button_label)
+            self._ui["channels_dialog"] = dialog
+        dialog.show()
+        dialog.raise_()
+        dialog.activateWindow()
+
+    def _update_channels_button_label(self) -> None:
+        """Update the channels button label based on saved data."""
+        button = self._ui.get("channels_button")
+        if button is None:
+            return
+        data = self._state.data
+        if isinstance(data, SpotsFeatureData) and (
+            data.channels or data.segmentations
+        ):
+            button.setText("Edit channels")
+        else:
+            button.setText("Add channels")
+
+    def export(self, temp_dir: Path, export_format: str):
+        """Export spots outputs into a temporary directory.
+
+        Parameters
+        ----------
+        temp_dir : Path
+            Temporary directory where outputs should be written.
+        export_format : str
+            File format requested by the user (``"csv"`` or ``"xlsx"``).
+
+        Returns
+        -------
+        iterable of Path
+            Paths to files produced by the export routine.
+        """
+        return export_spots(
+            self._state,
+            temp_dir,
+            viewer=self._tab._viewer,
+            export_format=export_format,
+        )

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

@@ -0,0 +1,279 @@
+"""Morphological descriptor extraction for spots cells table.
+
+This module provides utilities to extract morphological properties
+from cell segmentations used in spots analysis. Morphology is only
+added to the cells table, not the spots table.
+
+Descriptors include area/volume, shape metrics, and perimeter.
+"""
+
+from __future__ import annotations
+
+import warnings
+
+import numpy as np
+from skimage.measure import regionprops_table
+
+# Float-valued morphological properties to extract from regionprops.
+MORPHOLOGY_PROPERTIES = (
+    "area",  # Number of pixels in the region
+    "eccentricity",  # Eccentricity of the ellipse fitted to the region
+    "extent",  # Ratio of region area to bounding box area
+    "feret_diameter_max",  # Maximum Feret diameter
+    "major_axis_length",  # Major axis of the ellipse fitted to the region
+    "minor_axis_length",  # Minor axis of the ellipse fitted to the region
+    "orientation",  # Angle between the major axis and horizontal
+    "perimeter",  # Perimeter estimated by the Freeman chain code
+    "perimeter_crofton",  # Crofton perimeter (Euclidean-like estimate)
+    "solidity",  # Ratio of region area to convex hull area
+)
+
+NDIM_2D = 2
+NDIM_3D = 3
+
+
+def _collect_simple_properties(
+    props: dict,
+    label_ids: np.ndarray,
+) -> dict[str, np.ndarray]:
+    """Extract simple (non-array) properties from regionprops.
+
+    Parameters
+    ----------
+    props : dict
+        Output from regionprops_table.
+    label_ids : numpy.ndarray
+        Label ids for indexing.
+
+    Returns
+    -------
+    dict of str to numpy.ndarray
+        Simple property arrays keyed by property name.
+
+    """
+    result: dict[str, np.ndarray] = {}
+    for prop_name, prop_values in props.items():
+        if prop_name == "label":
+            continue
+
+        if isinstance(prop_values, list) and prop_values:
+            first_val = prop_values[0]
+            if isinstance(first_val, (np.ndarray, list, tuple)):
+                continue
+
+        try:
+            prop_array = np.asarray(prop_values, dtype=float)
+            if prop_array.size == len(label_ids):
+                result[f"morph_{prop_name}"] = prop_array
+        except (ValueError, TypeError):
+            continue
+
+    return result
+
+
+def _compute_derived_metrics(
+    result: dict[str, np.ndarray],
+) -> None:
+    """Compute derived morphological metrics in-place.
+
+    Parameters
+    ----------
+    result : dict of str to numpy.ndarray
+        Morphological properties to augment with derived metrics.
+
+    Notes
+    -----
+    Circularity is 2D-only: 4*pi*area / perimeter^2. It is only computed
+    when perimeter is available (which indicates 2D data).
+    Aspect ratio is 2D-only and only computed when major/minor axis lengths
+    are present in the result.
+
+    """
+    # Get area/volume (whichever exists after dimensionality-based renaming)
+    if "morph_area" in result:
+        area_or_volume = result["morph_area"]
+    elif "morph_volume" in result:
+        area_or_volume = result["morph_volume"]
+    else:
+        return
+
+    # Circularity is 2D-only: 4*pi*area / perimeter^2
+    if "morph_perimeter" in result:
+        perim = result["morph_perimeter"]
+        circularity = np.divide(
+            4 * np.pi * area_or_volume,
+            perim ** 2,
+            out=np.full_like(area_or_volume, np.nan),
+            where=perim != 0,
+        )
+        result["morph_circularity"] = circularity
+
+    # Aspect ratio: only computed if major/minor axis lengths are present (2D only)
+    if (
+        "morph_major_axis_length" in result
+        and "morph_minor_axis_length" in result
+    ):
+        major = result["morph_major_axis_length"]
+        minor = result["morph_minor_axis_length"]
+        aspect_ratio = np.divide(
+            major,
+            minor,
+            out=np.full_like(major, np.nan),
+            where=minor != 0,
+        )
+        result["morph_aspect_ratio"] = aspect_ratio
+
+
+def _compute_physical_area(
+    result: dict[str, np.ndarray],
+    pixel_sizes: np.ndarray,
+) -> None:
+    """Add physical area/volume measurements to result in-place.
+
+    Parameters
+    ----------
+    result : dict of str to numpy.ndarray
+        Morphological properties to augment.
+    pixel_sizes : numpy.ndarray
+        Per-axis pixel sizes in micrometers.
+
+    """
+    # Determine if we have area (2D) or volume (3D)
+    if "morph_area" in result:
+        area_or_volume = result["morph_area"]
+        is_volume = False
+    elif "morph_volume" in result:
+        area_or_volume = result["morph_volume"]
+        is_volume = True
+    else:
+        return
+
+    pixels = area_or_volume
+    ndim = len(pixel_sizes)
+
+    try:
+        if ndim == NDIM_2D and not is_volume:
+            area_phys = pixels * (pixel_sizes[0] * pixel_sizes[1])
+            result["morph_area_um2"] = area_phys
+        elif ndim == NDIM_3D and is_volume:
+            volume_phys = pixels * (
+                pixel_sizes[0] * pixel_sizes[1] * pixel_sizes[2]
+            )
+            result["morph_volume_um3"] = volume_phys
+    except (TypeError, ValueError):
+        pass
+
+
+def extract_morphology(
+    labels: np.ndarray,
+    label_ids: np.ndarray,
+    pixel_sizes: np.ndarray | None = None,
+) -> dict[str, np.ndarray]:
+    """Extract morphological descriptors for each labeled region.
+
+    Parameters
+    ----------
+    labels : numpy.ndarray
+        Label image with integer ids.
+    label_ids : numpy.ndarray
+        Specific label ids to extract properties for.
+    pixel_sizes : numpy.ndarray or None, optional
+        Per-axis pixel sizes in micrometers. When provided, physical
+        measurements are computed.
+
+    Returns
+    -------
+    dict of str to numpy.ndarray
+        Morphological descriptors. Keys are property names and values are
+        arrays with one entry per label id.
+
+    Notes
+    -----
+    Properties that depend on regionprops (e.g., eccentricity, solidity)
+    are only available for 2D images. For 3D, only simple properties like
+    volume are available.
+
+    The "area" property is renamed to "volume" for 3D images.
+
+    Some properties may not be available depending on the scikit-image
+    version. Missing properties are silently skipped.
+
+    """
+    # For 3D, some properties are not available. Try with all properties first,
+    # and fall back to basic properties if it fails.
+    try:
+        props = regionprops_table(
+            labels,
+            properties=MORPHOLOGY_PROPERTIES,
+        )
+    except (ValueError, RuntimeError):
+        # Fall back to basic properties for 3D
+        try:
+            props = regionprops_table(
+                labels,
+                properties=("area",),
+            )
+        except (ValueError, RuntimeError) as exc:
+            warnings.warn(
+                f"Failed to extract morphological properties: {exc}",
+                RuntimeWarning,
+                stacklevel=2,
+            )
+            return {}
+
+    result = _collect_simple_properties(props, label_ids)
+
+    # For 3D images, rename "area" to "volume"
+    if labels.ndim == NDIM_3D and "morph_area" in result:
+        result["morph_volume"] = result.pop("morph_area")
+
+    _compute_derived_metrics(result)
+
+    if pixel_sizes is not None:
+        _compute_physical_area(result, pixel_sizes)
+
+    return result
+
+
+def add_morphology_columns(
+    rows: list[dict],
+    labels: np.ndarray,
+    label_ids: np.ndarray,
+    pixel_sizes: np.ndarray | None = None,
+) -> list[str]:
+    """Add morphological descriptor columns to output rows.
+
+    Parameters
+    ----------
+    rows : list of dict
+        Output row dictionaries to update in-place.
+    labels : numpy.ndarray
+        Label image with integer ids.
+    label_ids : numpy.ndarray
+        Label ids corresponding to the output rows.
+    pixel_sizes : numpy.ndarray or None, optional
+        Per-axis pixel sizes in micrometers.
+
+    Returns
+    -------
+    list of str
+        List of column names added to the rows.
+
+    Notes
+    -----
+    This function modifies ``rows`` in-place and returns the list of new
+    column names that were added for header generation.
+
+    """
+    morphology_data = extract_morphology(labels, label_ids, pixel_sizes)
+
+    if not morphology_data or not rows:
+        return []
+
+    column_names: list[str] = []
+    for col_name, col_values in morphology_data.items():
+        column_names.append(col_name)
+        for row, value in zip(rows, col_values, strict=True):
+            row[col_name] = float(value) if not np.isnan(value) else value
+
+    return column_names

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

@@ -0,0 +1,241 @@
+"""Spots channels dialog rows."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from qtpy.QtWidgets import (
+    QFormLayout,
+    QGroupBox,
+    QLineEdit,
+    QPushButton,
+    QSizePolicy,
+    QVBoxLayout,
+    QWidget,
+)
+
+from ..base import RefreshingComboBox
+from .config import SpotsChannelConfig, SpotsSegmentationConfig
+
+if TYPE_CHECKING:
+    from .dialog import SpotsChannelsDialog
+
+
+class SpotsSegmentationRow(QGroupBox):
+    """Segmentation row widget for spots segmentation filters."""
+
+    def __init__(
+        self, dialog: SpotsChannelsDialog, data: SpotsSegmentationConfig
+    ) -> None:
+        """Initialize a segmentation row widget.
+
+        Parameters
+        ----------
+        dialog : SpotsChannelsDialog
+            Parent dialog instance.
+        data : SpotsSegmentationConfig
+            Segmentation configuration data.
+        """
+        super().__init__()
+        self._dialog = dialog
+        self._tab = dialog._tab
+        self.data = data
+
+        self.setFlat(True)
+        self.setStyleSheet(
+            "QGroupBox {"
+            "  margin-top: 6px;"
+            "}"
+            "QGroupBox::title {"
+            "  subcontrol-origin: margin;"
+            "  subcontrol-position: top left;"
+            "  padding: 0 6px;"
+            "}"
+        )
+
+        layout = QVBoxLayout()
+        layout.setContentsMargins(8, 8, 8, 8)
+        layout.setSpacing(6)
+
+        form_layout = QFormLayout()
+        form_layout.setFieldGrowthPolicy(QFormLayout.AllNonFixedFieldsGrow)
+        labels_combo = RefreshingComboBox(
+            refresh_callback=lambda combo_ref=None: self._dialog._refresh_labels_combo(
+                labels_combo, filter_type="cellular"
+            )
+        )
+        self._tab._configure_combo(labels_combo)
+        labels_combo.currentTextChanged.connect(
+            lambda text: self._set_data("label", text)
+        )
+
+        form_layout.addRow("Segmentation", labels_combo)
+        layout.addLayout(form_layout)
+
+        delete_button = QPushButton("Delete")
+        delete_button.clicked.connect(
+            lambda: self._dialog._remove_segmentation(self)
+        )
+        layout.addWidget(delete_button)
+
+        self._labels_combo = labels_combo
+        self.setLayout(layout)
+        self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
+        self._restore_state()
+
+    def update_title(self, index: int) -> None:
+        """Update the title label for the segmentation row.
+
+        Parameters
+        ----------
+        index : int
+            0-based index used in the title.
+        """
+        self.setTitle(f"Segmentation {index}")
+
+    def _set_data(self, key: str, value) -> None:
+        """Update the segmentation data model.
+
+        Parameters
+        ----------
+        key : str
+            Data field name to update.
+        value : object
+            Value to assign to the field.
+        """
+        setattr(self.data, key, value)
+
+    def _restore_state(self) -> None:
+        """Restore UI state from stored segmentation data.
+
+        Notes
+        -----
+        This sets the labels combo to the stored label name when available.
+        """
+        label_name = self.data.label
+        if label_name:
+            self._labels_combo.setCurrentText(label_name)
+        return
+
+
+class SpotsChannelRow(QGroupBox):
+    """Channel row widget for spots feature channels."""
+
+    def __init__(
+        self, dialog: SpotsChannelsDialog, data: SpotsChannelConfig
+    ) -> None:
+        """Initialize a channel row widget.
+
+        Parameters
+        ----------
+        dialog : SpotsChannelsDialog
+            Parent dialog instance.
+        data : SpotsChannelConfig
+            Channel configuration data.
+        """
+        super().__init__()
+        self._dialog = dialog
+        self._tab = dialog._tab
+        self.data = data
+
+        self.setFlat(True)
+        self.setStyleSheet(
+            "QGroupBox {"
+            "  margin-top: 6px;"
+            "}"
+            "QGroupBox::title {"
+            "  subcontrol-origin: margin;"
+            "  subcontrol-position: top left;"
+            "  padding: 0 6px;"
+            "}"
+        )
+
+        layout = QVBoxLayout()
+        layout.setContentsMargins(8, 8, 8, 8)
+        layout.setSpacing(6)
+
+        channel_form = QFormLayout()
+        channel_form.setFieldGrowthPolicy(QFormLayout.AllNonFixedFieldsGrow)
+        name_input = QLineEdit()
+        name_input.setPlaceholderText("Channel name")
+        name_input.setMinimumWidth(160)
+        name_input.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
+        name_input.textChanged.connect(
+            lambda text: self._set_data("name", text)
+        )
+        channel_combo = RefreshingComboBox(
+            refresh_callback=lambda combo_ref=None: self._dialog._refresh_image_combo(
+                channel_combo
+            )
+        )
+        self._tab._configure_combo(channel_combo)
+        channel_combo.currentTextChanged.connect(
+            lambda text: self._set_data("channel", text)
+        )
+        segmentation_combo = RefreshingComboBox(
+            refresh_callback=lambda combo_ref=None: self._dialog._refresh_labels_combo(
+                segmentation_combo, filter_type="spots"
+            )
+        )
+        self._tab._configure_combo(segmentation_combo)
+        segmentation_combo.currentTextChanged.connect(
+            lambda text: self._set_data("spots_segmentation", text)
+        )
+
+        channel_form.addRow("Name", name_input)
+        channel_form.addRow("Channel", channel_combo)
+        channel_form.addRow("Spots segmentation", segmentation_combo)
+        layout.addLayout(channel_form)
+
+        delete_button = QPushButton("Delete")
+        delete_button.clicked.connect(lambda: self._dialog._remove_channel(self))
+        layout.addWidget(delete_button)
+
+        self.setLayout(layout)
+
+        self._channel_combo = channel_combo
+        self._name_input = name_input
+        self._segmentation_combo = segmentation_combo
+
+        self._restore_state()
+        self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
+
+    def update_title(self, index: int) -> None:
+        """Update the title label for the channel row.
+
+        Parameters
+        ----------
+        index : int
+            0-based index used in the title.
+        """
+        self.setTitle(f"Channel {index}")
+
+    def _set_data(self, key: str, value) -> None:
+        """Update the channel data model.
+
+        Parameters
+        ----------
+        key : str
+            Data key to update.
+        value : object
+            New value to store.
+        """
+        setattr(self.data, key, value)
+
+    def _restore_state(self) -> None:
+        """Restore UI state from stored channel data.
+
+        Notes
+        -----
+        Populates name, channel, and segmentation combos when values are
+        present in the configuration.
+        """
+        channel_label = self.data.name
+        if channel_label:
+            self._name_input.setText(channel_label)
+        channel_name = self.data.channel
+        if channel_name:
+            self._channel_combo.setCurrentText(channel_name)
+        segmentation_name = self.data.spots_segmentation
+        if segmentation_name:
+            self._segmentation_combo.setCurrentText(segmentation_name)