senoquant 1.0.0b1__py3-none-any.whl

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

@@ -0,0 +1,119 @@
+"""Marker feature UI."""
+
+from pathlib import Path
+
+from qtpy.QtWidgets import QDialog, QPushButton
+
+from ..base import SenoQuantFeature
+from ..roi import ROISection
+from .config import MarkerFeatureData
+from .dialog import MarkerChannelsDialog
+from .export import export_marker
+
+
+class MarkerFeature(SenoQuantFeature):
+    """Marker feature controls."""
+
+    feature_type = "Markers"
+    order = 10
+
+    def build(self) -> None:
+        """Build the marker feature UI."""
+        self._build_channels_section()
+        data = self._state.data
+        if getattr(self._tab, "_enable_rois", True):
+            if isinstance(data, MarkerFeatureData):
+                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)
+        self._ui["channels_button"] = button
+        self._update_channels_button_label()
+
+    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 = MarkerChannelsDialog(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, MarkerFeatureData) and (
+            data.channels or data.segmentations
+        ):
+            button.setText("Edit channels")
+        else:
+            button.setText("Add channels")
+
+    def _get_image_layer_by_name(self, name: str):
+        """Return the image layer with the provided name.
+
+        Parameters
+        ----------
+        name : str
+            Image layer name.
+
+        Returns
+        -------
+        object or None
+            Matching image layer or None if not found.
+        """
+        viewer = self._tab._viewer
+        if viewer is None or not name:
+            return None
+        for layer in viewer.layers:
+            if layer.__class__.__name__ == "Image" and layer.name == name:
+                return layer
+        return None
+
+    def export(self, temp_dir: Path, export_format: str):
+        """Export marker 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_marker(
+            self._state,
+            temp_dir,
+            viewer=self._tab._viewer,
+            export_format=export_format,
+            enable_thresholds=getattr(self._tab, "_enable_thresholds", True),
+        )

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

@@ -0,0 +1,285 @@
+"""Morphological descriptor extraction from regionprops.
+
+This module provides utilities to extract additional morphological properties
+from segmented regions. It focuses on float-valued descriptors that describe
+cell/nucleus shape, size, and topology.
+
+Descriptors include:
+- Area and perimeter metrics
+- Shape descriptors (eccentricity, solidity, etc.)
+- Axis ratios and moments
+- Convexity and aspect ratios
+"""
+
+from __future__ import annotations
+
+import warnings
+
+import numpy as np
+from skimage.measure import regionprops_table
+
+# Float-valued morphological properties to extract from regionprops.
+# Note: Array-valued properties (moments, etc.) are excluded.
+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[str, float]],
+    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
+