datalab-platform 0.0.1.dev0__py3-none-any.whl → 1.0.0__py3-none-any.whl

datalab/adapters_plotpy/objects/signal.py

@@ -0,0 +1,264 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+PlotPy Adapter Signal Module
+----------------------------
+"""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+
+from __future__ import annotations
+
+from contextlib import contextmanager
+from typing import Generator
+
+import numpy as np
+from guidata.dataset import restore_dataset, update_dataset
+from plotpy.builder import make
+from plotpy.items import CurveItem
+from sigima.objects import SignalObj
+
+from datalab.adapters_plotpy.objects.base import (
+    BaseObjPlotPyAdapter,
+)
+from datalab.config import Conf
+
+
+class CurveStyles:
+    """Object to manage curve styles"""
+
+    #: Curve colors
+    COLORS = (
+        "#1f77b4",  # muted blue
+        "#ff7f0e",  # safety orange
+        "#2ca02c",  # cooked asparagus green
+        "#d62728",  # brick red
+        "#9467bd",  # muted purple
+        "#8c564b",  # chestnut brown
+        "#e377c2",  # raspberry yogurt pink
+        "#7f7f7f",  # gray
+        "#bcbd22",  # curry yellow-green
+        "#17becf",  # blue-teal
+    )
+    #: Curve line styles
+    LINESTYLES = ("SolidLine", "DashLine", "DashDotLine", "DashDotDotLine")
+
+    def __init__(self) -> None:
+        self.__suspend = False
+        self.curve_style = self.style_generator()
+
+    @staticmethod
+    def style_generator() -> Generator[tuple[str, str], None, None]:
+        """Cycling through curve styles"""
+        while True:
+            for linestyle in CurveStyles.LINESTYLES:
+                for color in CurveStyles.COLORS:
+                    yield (color, linestyle)
+
+    def apply_style(self, item: CurveItem) -> None:
+        """Apply style to curve
+
+        Args:
+            item: curve item
+        """
+        if self.__suspend:
+            # Suspend mode: always apply the first style
+            color, linestyle = CurveStyles.COLORS[0], CurveStyles.LINESTYLES[0]
+        else:
+            color, linestyle = next(self.curve_style)
+        item.param.line.color = color
+        item.param.line.style = linestyle
+        item.param.symbol.marker = "NoSymbol"
+        # Note: line width is set separately via apply_line_width()
+        # to ensure it's always recalculated based on current data size and settings
+
+    def reset_styles(self) -> None:
+        """Reset styles"""
+        self.curve_style = self.style_generator()
+
+    @contextmanager
+    def alternative(
+        self, other_style_generator: Generator[tuple[str, str], None, None]
+    ) -> Generator[None, None, None]:
+        """Use an alternative style generator"""
+        old_style_generator = self.curve_style
+        self.curve_style = other_style_generator
+        yield
+        self.curve_style = old_style_generator
+
+    @contextmanager
+    def suspend(self) -> Generator[None, None, None]:
+        """Suspend style generator"""
+        self.__suspend = True
+        yield
+        self.__suspend = False
+
+
+CURVESTYLES = CurveStyles()  # This is the unique instance of the CurveStyles class
+
+
+def apply_line_width(item: CurveItem) -> None:
+    """Apply line width to curve item with smart clamping for large datasets
+
+    Args:
+        item: curve item
+    """
+    # Get data size
+    data_size = item.get_data()[0].size
+
+    # Get configured line width
+    line_width = Conf.view.sig_linewidth.get()
+
+    # For large datasets, clamp linewidth to 1.0 for performance
+    # (thick lines cause ~10x rendering slowdown due to Qt raster engine)
+    threshold = Conf.view.sig_linewidth_perfs_threshold.get()
+    if data_size > threshold and line_width > 1.0:
+        line_width = 1.0
+
+    # Apply the line width
+    item.param.line.width = line_width
+
+
+def apply_downsampling(item: CurveItem, do_not_update: bool = False) -> None:
+    """Apply downsampling to curve item
+
+    Args:
+        item: curve item
+        do_not_update: if True, do not update the item even if the downsampling
+         parameters have changed
+    """
+    old_use_dsamp = item.param.use_dsamp
+    item.param.use_dsamp = False
+    if Conf.view.sig_autodownsampling.get():
+        nbpoints = item.get_data()[0].size
+        maxpoints = Conf.view.sig_autodownsampling_maxpoints.get()
+        if nbpoints > 5 * maxpoints:
+            item.param.use_dsamp = True
+            item.param.dsamp_factor = nbpoints // maxpoints
+    if not do_not_update and old_use_dsamp != item.param.use_dsamp:
+        item.update_data()
+
+
+class SignalObjPlotPyAdapter(BaseObjPlotPyAdapter[SignalObj, CurveItem]):
+    """Signal object plot item adapter class"""
+
+    CONF_FMT = Conf.view.sig_format
+    DEFAULT_FMT = "g"
+
+    def update_plot_item_parameters(self, item: CurveItem) -> None:
+        """Update plot item parameters from object data/metadata
+
+        Takes into account a subset of plot item parameters. Those parameters may
+        have been overriden by object metadata entries or other object data. The goal
+        is to update the plot item accordingly.
+
+        This is *almost* the inverse operation of `update_metadata_from_plot_item`.
+
+        Args:
+            item: plot item
+        """
+        update_dataset(item.param.line, self.obj.metadata)
+        update_dataset(item.param.symbol, self.obj.metadata)
+        super().update_plot_item_parameters(item)
+
+    def update_metadata_from_plot_item(self, item: CurveItem) -> None:
+        """Update metadata from plot item.
+
+        Takes into account a subset of plot item parameters. Those parameters may
+        have been modified by the user through the plot item GUI. The goal is to
+        update the metadata accordingly.
+
+        This is *almost* the inverse operation of `update_plot_item_parameters`.
+
+        Args:
+            item: plot item
+        """
+        super().update_metadata_from_plot_item(item)
+        restore_dataset(item.param.line, self.obj.metadata)
+        restore_dataset(item.param.symbol, self.obj.metadata)
+
+    def make_item(self, update_from: CurveItem | None = None) -> CurveItem:
+        """Make plot item from data.
+
+        Args:
+            update_from: plot item to update from
+
+        Returns:
+            Plot item
+        """
+        o = self.obj
+        if len(o.xydata) in (2, 4):
+            assert isinstance(o.xydata, np.ndarray)
+            if len(o.xydata) == 2:  # x, y signal
+                x, y = o.xydata
+                item = make.mcurve(x.real, y.real, label=o.title)
+            else:  # x, y, dx, dy error bar signal
+                x, y, dx, dy = o.xydata
+                if o.dx is None and o.dy is None:  # x, y signal with no error
+                    item = make.mcurve(x.real, y.real, label=o.title)
+                elif o.dx is None:  # x, y, dy error bar signal with y error
+                    item = make.merror(x.real, y.real, dy.real, label=o.title)
+                else:  # x, y, dx, dy error bar signal with x error
+                    dy = np.zeros_like(y) if dy is None else dy
+                    item = make.merror(x.real, y.real, dx.real, dy.real, label=o.title)
+            # Apply style (without linewidth, will be set separately)
+            CURVESTYLES.apply_style(item)
+            apply_downsampling(item, do_not_update=True)
+            # Apply linewidth with smart clamping based on actual data size
+            apply_line_width(item)
+        else:
+            raise RuntimeError("data not supported")
+        if update_from is None:
+            self.update_plot_item_parameters(item)
+        else:
+            update_dataset(item.param, update_from.param)
+            item.update_params()
+        return item
+
+    def update_item(self, item: CurveItem, data_changed: bool = True) -> None:
+        """Update plot item from data.
+
+        Args:
+            item: plot item
+            data_changed: if True, data has changed
+        """
+        o = self.obj
+        if data_changed:
+            assert isinstance(o.xydata, np.ndarray)
+            if len(o.xydata) == 2:  # x, y signal
+                x, y = o.xydata
+                assert isinstance(x, np.ndarray) and isinstance(y, np.ndarray)
+                item.set_data(x.real, y.real)
+            elif len(o.xydata) == 3:  # x, y, dy error bar signal
+                x, y, dy = o.xydata
+                assert (
+                    isinstance(x, np.ndarray)
+                    and isinstance(y, np.ndarray)
+                    and isinstance(dy, np.ndarray)
+                )
+                item.set_data(x.real, y.real, dy=dy.real)
+            elif len(o.xydata) == 4:  # x, y, dx, dy error bar signal
+                x, y, dx, dy = o.xydata
+                assert (
+                    isinstance(x, np.ndarray)
+                    and isinstance(y, np.ndarray)
+                    and isinstance(dx, np.ndarray)
+                    and isinstance(dy, np.ndarray)
+                )
+                item.set_data(x.real, y.real, dx.real, dy.real)
+        item.param.label = o.title
+        apply_downsampling(item)
+        # Reapply linewidth with smart clamping (data size may have changed)
+        apply_line_width(item)
+        self.update_plot_item_parameters(item)
+
+    def add_label_with_title(self, title: str | None = None) -> None:
+        """Add label with title annotation
+
+        Args:
+            title: title (if None, use signal title)
+        """
+        title = self.obj.title if title is None else title
+        if title:
+            label = make.label(title, "TL", (0, 0), "TL")
+            self.add_annotations_from_items([label])

datalab/adapters_plotpy/roi/base.py

@@ -0,0 +1,146 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+PlotPy Adapter Base ROI Module
+------------------------------
+"""
+
+import abc
+from typing import TYPE_CHECKING, Generic, Iterator, Literal, TypeVar
+
+from plotpy.items import AnnotatedShape
+from sigima.objects.base import (
+    BaseROI,
+    TypeObj,
+    TypeROI,
+    TypeROIParam,
+    TypeSingleROI,
+    get_generic_roi_title,
+)
+
+from datalab.adapters_plotpy.base import config_annotated_shape
+
+if TYPE_CHECKING:
+    from plotpy.items import (
+        AnnotatedCircle,
+        AnnotatedPolygon,
+        AnnotatedRectangle,
+        AnnotatedXRange,
+    )
+
+TypeROIItem = TypeVar(
+    "TypeROIItem",
+    bound="AnnotatedXRange | AnnotatedPolygon | AnnotatedRectangle | AnnotatedCircle",
+)
+
+
+class BaseSingleROIPlotPyAdapter(Generic[TypeSingleROI, TypeROIItem], abc.ABC):
+    """Base class for single ROI plot item adapter
+
+    Args:
+        single_roi: single ROI object
+    """
+
+    def __init__(self, single_roi: TypeSingleROI) -> None:
+        self.single_roi = single_roi
+
+    @abc.abstractmethod
+    def to_plot_item(self, obj: TypeObj) -> TypeROIItem:
+        """Make ROI plot item from ROI.
+
+        Args:
+            obj: object (signal/image), for physical-indices coordinates conversion
+
+        Returns:
+            Plot item
+        """
+
+    @classmethod
+    @abc.abstractmethod
+    def from_plot_item(cls, item: TypeROIItem) -> TypeSingleROI:
+        """Create single ROI from plot item
+
+        Args:
+            item: plot item
+
+        Returns:
+            Single ROI
+        """
+
+
+def configure_roi_item(
+    item: TypeROIItem,
+    fmt: str,
+    lbl: bool,
+    editable: bool,
+    option: Literal["s", "i"],
+):
+    """Configure ROI plot item.
+
+    Args:
+        item: plot item
+        fmt: numeric format (e.g. "%.3f")
+        lbl: if True, show shape labels
+        editable: if True, make shape editable
+        option: shape style option ("s" for signal, "i" for image)
+
+    Returns:
+        Plot item
+    """
+    option += "/" + ("editable" if editable else "readonly")
+    if not editable:
+        if isinstance(item, AnnotatedShape):
+            config_annotated_shape(
+                item, fmt, lbl, "roi", option, show_computations=editable
+            )
+        item.set_movable(False)
+        item.set_resizable(False)
+        item.set_readonly(True)
+    item.set_style("roi", option)
+    return item
+
+
+class BaseROIPlotPyAdapter(Generic[TypeROI], abc.ABC):
+    """ROI plot item adapter class
+
+    Args:
+        roi: ROI object
+    """
+
+    def __init__(self, roi: BaseROI[TypeObj, TypeSingleROI, TypeROIParam]) -> None:
+        self.roi = roi
+
+    @abc.abstractmethod
+    def to_plot_item(self, single_roi: TypeSingleROI, obj: TypeObj) -> TypeROIItem:
+        """Make ROI plot item from single ROI
+
+        Args:
+            single_roi: single ROI object
+            obj: object (signal/image), for physical-indices coordinates conversion
+
+        Returns:
+            Plot item
+        """
+
+    def iterate_roi_items(
+        self, obj: TypeObj, fmt: str, lbl: bool, editable: bool = True
+    ) -> Iterator[TypeROIItem]:
+        """Iterate over ROI plot items associated to each single ROI composing
+        the object.
+
+        Args:
+            obj: object (signal/image), for physical-indices coordinates conversion
+            fmt: format string
+            lbl: if True, add label
+            editable: if True, ROI is editable
+
+        Yields:
+            Plot item
+        """
+        for index, single_roi in enumerate(self.roi.single_rois):
+            roi_item = self.to_plot_item(single_roi, obj)
+            item = configure_roi_item(
+                roi_item, fmt, lbl, editable, option=self.roi.PREFIX
+            )
+            item.setTitle(single_roi.title or get_generic_roi_title(index))
+            yield item

datalab/adapters_plotpy/roi/factory.py

@@ -0,0 +1,93 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+ROI Adapter Factory
+-------------------
+
+Factory functions for creating ROI adapters without circular imports.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from sigima.objects.base import TypeObj
+
+
+def create_roi_adapter(roi):
+    """Create ROI adapter from ROI object
+
+    Args:
+        roi: ROI object
+
+    Returns:
+        ROI adapter instance
+    """
+    # pylint: disable=import-outside-toplevel
+    from sigima.objects import (
+        CircularROI,
+        ImageROI,
+        PolygonalROI,
+        RectangularROI,
+        SegmentROI,
+        SignalROI,
+    )
+
+    if isinstance(roi, SignalROI):
+        from datalab.adapters_plotpy.roi.signal import SignalROIPlotPyAdapter
+
+        return SignalROIPlotPyAdapter(roi)
+    if isinstance(roi, RectangularROI):
+        from datalab.adapters_plotpy.roi.image import RectangularROIPlotPyAdapter
+
+        return RectangularROIPlotPyAdapter(roi)
+    if isinstance(roi, CircularROI):
+        from datalab.adapters_plotpy.roi.image import CircularROIPlotPyAdapter
+
+        return CircularROIPlotPyAdapter(roi)
+    if isinstance(roi, PolygonalROI):
+        from datalab.adapters_plotpy.roi.image import PolygonalROIPlotPyAdapter
+
+        return PolygonalROIPlotPyAdapter(roi)
+    if isinstance(roi, ImageROI):
+        from datalab.adapters_plotpy.roi.image import ImageROIPlotPyAdapter
+
+        return ImageROIPlotPyAdapter(roi)
+    if isinstance(roi, SegmentROI):
+        from datalab.adapters_plotpy.roi.signal import SegmentROIPlotPyAdapter
+
+        return SegmentROIPlotPyAdapter(roi)
+    raise TypeError(f"Unsupported ROI type: {type(roi)}")
+
+
+def create_single_roi_plot_item(single_roi, obj: TypeObj):
+    """Create plot item from single ROI
+
+    Args:
+        single_roi: single ROI object
+        obj: object (signal/image), for physical-indices coordinates conversion
+
+    Returns:
+        Plot item
+    """
+    # pylint: disable=import-outside-toplevel
+    from sigima.objects import (
+        CircularROI,
+        PolygonalROI,
+        RectangularROI,
+    )
+
+    if isinstance(single_roi, RectangularROI):
+        from datalab.adapters_plotpy.roi.image import RectangularROIPlotPyAdapter
+
+        return RectangularROIPlotPyAdapter(single_roi).to_plot_item(obj)
+    if isinstance(single_roi, CircularROI):
+        from datalab.adapters_plotpy.roi.image import CircularROIPlotPyAdapter
+
+        return CircularROIPlotPyAdapter(single_roi).to_plot_item(obj)
+    if isinstance(single_roi, PolygonalROI):
+        from datalab.adapters_plotpy.roi.image import PolygonalROIPlotPyAdapter
+
+        return PolygonalROIPlotPyAdapter(single_roi).to_plot_item(obj)
+    raise TypeError(f"Unsupported ROI type: {type(single_roi)}")