bec-widgets 1.4.0__py3-none-any.whl → 1.5.0__py3-none-any.whl

bec_widgets/utils/crosshair.py

@@ -6,13 +6,16 @@ from qtpy.QtCore import QObject, Qt, Signal, Slot
 from qtpy.QtWidgets import QApplication
 
 
-class NonDownsamplingScatterPlotItem(pg.ScatterPlotItem):
+class CrosshairScatterItem(pg.ScatterPlotItem):
     def setDownsampling(self, ds=None, auto=None, method=None):
         pass
 
     def setClipToView(self, state):
         pass
 
+    def setAlpha(self, *args, **kwargs):
+        pass
+
 
 class Crosshair(QObject):
     # QT Position of mouse cursor
@@ -47,9 +50,15 @@ class Crosshair(QObject):
         self.v_line.skip_auto_range = True
         self.h_line = pg.InfiniteLine(angle=0, movable=False)
         self.h_line.skip_auto_range = True
+        # Add custom attribute to identify crosshair lines
+        self.v_line.is_crosshair = True
+        self.h_line.is_crosshair = True
         self.plot_item.addItem(self.v_line, ignoreBounds=True)
         self.plot_item.addItem(self.h_line, ignoreBounds=True)
 
+        # Initialize highlighted curve in a case of multiple curves
+        self.highlighted_curve_index = None
+
         # Add TextItem to display coordinates
         self.coord_label = pg.TextItem("", anchor=(1, 1), fill=(0, 0, 0, 100))
         self.coord_label.setVisible(False)  # Hide initially
@@ -70,6 +79,7 @@ class Crosshair(QObject):
         self.plot_item.ctrl.downsampleSpin.valueChanged.connect(self.clear_markers)
 
         # Initialize markers
+        self.items = []
         self.marker_moved_1d = {}
         self.marker_clicked_1d = {}
         self.marker_2d = None
@@ -113,34 +123,74 @@ class Crosshair(QObject):
         self.coord_label.fill = pg.mkBrush(label_bg_color)
         self.coord_label.border = pg.mkPen(None)
 
+    @Slot(int)
+    def update_highlighted_curve(self, curve_index: int):
+        """
+        Update the highlighted curve in the case of multiple curves in a plot item.
+
+        Args:
+            curve_index(int): The index of curve to highlight
+        """
+        self.highlighted_curve_index = curve_index
+        self.clear_markers()
+        self.update_markers()
+
     def update_markers(self):
         """Update the markers for the crosshair, creating new ones if necessary."""
 
-        # Create new markers
-        for item in self.plot_item.items:
+        if self.highlighted_curve_index is not None and hasattr(self.plot_item, "visible_curves"):
+            # Focus on the highlighted curve only
+            self.items = [self.plot_item.visible_curves[self.highlighted_curve_index]]
+        else:
+            # Handle all curves
+            self.items = self.plot_item.items
+
+        # Create or update markers
+        for item in self.items:
             if isinstance(item, pg.PlotDataItem):  # 1D plot
-                if item.name() in self.marker_moved_1d:
-                    continue
                 pen = item.opts["pen"]
                 color = pen.color() if hasattr(pen, "color") else pg.mkColor(pen)
-                marker_moved = NonDownsamplingScatterPlotItem(
-                    size=10, pen=pg.mkPen(color), brush=pg.mkBrush(None)
-                )
-                marker_moved.skip_auto_range = True
-                self.marker_moved_1d[item.name()] = marker_moved
-                self.plot_item.addItem(marker_moved)
-
-                # Create glowing effect markers for clicked events
-                for size, alpha in [(18, 64), (14, 128), (10, 255)]:
-                    marker_clicked = NonDownsamplingScatterPlotItem(
-                        size=size,
-                        pen=pg.mkPen(None),
-                        brush=pg.mkBrush(color.red(), color.green(), color.blue(), alpha),
+                name = item.name() or str(id(item))
+                if name in self.marker_moved_1d:
+                    # Update existing markers
+                    marker_moved = self.marker_moved_1d[name]
+                    marker_moved.setPen(pg.mkPen(color))
+                    # Update clicked markers' brushes
+                    for marker_clicked in self.marker_clicked_1d[name]:
+                        alpha = marker_clicked.opts["brush"].color().alpha()
+                        marker_clicked.setBrush(
+                            pg.mkBrush(color.red(), color.green(), color.blue(), alpha)
+                        )
+                    # Update z-values
+                    marker_moved.setZValue(item.zValue() + 1)
+                    for marker_clicked in self.marker_clicked_1d[name]:
+                        marker_clicked.setZValue(item.zValue() + 1)
+                else:
+                    # Create new markers
+                    marker_moved = CrosshairScatterItem(
+                        size=10, pen=pg.mkPen(color), brush=pg.mkBrush(None)
                     )
-                    marker_clicked.skip_auto_range = True
-                    self.marker_clicked_1d[item.name()] = marker_clicked
-                    self.plot_item.addItem(marker_clicked)
-
+                    marker_moved.skip_auto_range = True
+                    marker_moved.is_crosshair = True
+                    self.marker_moved_1d[name] = marker_moved
+                    self.plot_item.addItem(marker_moved)
+                    # Set marker z-value higher than the curve
+                    marker_moved.setZValue(item.zValue() + 1)
+
+                    # Create glowing effect markers for clicked events
+                    marker_clicked_list = []
+                    for size, alpha in [(18, 64), (14, 128), (10, 255)]:
+                        marker_clicked = CrosshairScatterItem(
+                            size=size,
+                            pen=pg.mkPen(None),
+                            brush=pg.mkBrush(color.red(), color.green(), color.blue(), alpha),
+                        )
+                        marker_clicked.skip_auto_range = True
+                        marker_clicked.is_crosshair = True
+                        self.plot_item.addItem(marker_clicked)
+                        marker_clicked.setZValue(item.zValue() + 1)
+                        marker_clicked_list.append(marker_clicked)
+                    self.marker_clicked_1d[name] = marker_clicked_list
             elif isinstance(item, pg.ImageItem):  # 2D plot
                 if self.marker_2d is not None:
                     continue
@@ -162,12 +212,11 @@ class Crosshair(QObject):
         """
         y_values = defaultdict(list)
         x_values = defaultdict(list)
-        image_2d = None
 
         # Iterate through items in the plot
-        for item in self.plot_item.items:
+        for item in self.items:
             if isinstance(item, pg.PlotDataItem):  # 1D plot
-                name = item.name()
+                name = item.name() or str(id(item))
                 plot_data = item._getDisplayDataset()
                 if plot_data is None:
                     continue
@@ -188,7 +237,7 @@ class Crosshair(QObject):
             elif isinstance(item, pg.ImageItem):  # 2D plot
                 name = item.config.monitor
                 image_2d = item.image
-                # clip the x and y values to the image dimensions to avoid out of bounds errors
+                # Clip the x and y values to the image dimensions to avoid out of bounds errors
                 y_values[name] = int(np.clip(y, 0, image_2d.shape[1] - 1))
                 x_values[name] = int(np.clip(x, 0, image_2d.shape[0] - 1))
 
@@ -256,9 +305,9 @@ class Crosshair(QObject):
                 # not sure how we got here, but just to be safe...
                 return
 
-            for item in self.plot_item.items:
+            for item in self.items:
                 if isinstance(item, pg.PlotDataItem):
-                    name = item.name()
+                    name = item.name() or str(id(item))
                     x, y = x_snap_values[name], y_snap_values[name]
                     if x is None or y is None:
                         continue
@@ -309,13 +358,14 @@ class Crosshair(QObject):
                 # not sure how we got here, but just to be safe...
                 return
 
-            for item in self.plot_item.items:
+            for item in self.items:
                 if isinstance(item, pg.PlotDataItem):
-                    name = item.name()
+                    name = item.name() or str(id(item))
                     x, y = x_snap_values[name], y_snap_values[name]
                     if x is None or y is None:
                         continue
-                    self.marker_clicked_1d[name].setData([x], [y])
+                    for marker_clicked in self.marker_clicked_1d[name]:
+                        marker_clicked.setData([x], [y])
                     x_snapped_scaled, y_snapped_scaled = self.scale_emitted_coordinates(x, y)
                     coordinate_to_emit = (
                         name,
@@ -337,9 +387,12 @@ class Crosshair(QObject):
     def clear_markers(self):
         """Clears the markers from the plot."""
         for marker in self.marker_moved_1d.values():
-            marker.clear()
-        for marker in self.marker_clicked_1d.values():
-            marker.clear()
+            self.plot_item.removeItem(marker)
+        for markers in self.marker_clicked_1d.values():
+            for marker in markers:
+                self.plot_item.removeItem(marker)
+        self.marker_moved_1d.clear()
+        self.marker_clicked_1d.clear()
 
     def scale_emitted_coordinates(self, x, y):
         """Scales the emitted coordinates if the axes are in log scale.
@@ -366,7 +419,7 @@ class Crosshair(QObject):
         x, y = pos
         x_scaled, y_scaled = self.scale_emitted_coordinates(x, y)
 
-        # # Update coordinate label
+        # Update coordinate label
         self.coord_label.setText(f"({x_scaled:.{self.precision}g}, {y_scaled:.{self.precision}g})")
         self.coord_label.setPos(x, y)
         self.coord_label.setVisible(True)

bec_widgets/widgets/dock/dock_area.py

@@ -24,6 +24,7 @@ from bec_widgets.widgets.dark_mode_button.dark_mode_button import DarkModeButton
 from bec_widgets.widgets.dock.dock import BECDock, DockConfig
 from bec_widgets.widgets.image.image_widget import BECImageWidget
 from bec_widgets.widgets.motor_map.motor_map_widget import BECMotorMapWidget
+from bec_widgets.widgets.multi_waveform.multi_waveform_widget import BECMultiWaveformWidget
 from bec_widgets.widgets.positioner_box.positioner_box import PositionerBox
 from bec_widgets.widgets.ring_progress_bar.ring_progress_bar import RingProgressBar
 from bec_widgets.widgets.scan_control.scan_control import ScanControl
@@ -85,6 +86,11 @@ class BECDockArea(BECWidget, QWidget):
                             tooltip="Add Waveform",
                             filled=True,
                         ),
+                        "multi_waveform": MaterialIconAction(
+                            icon_name=BECMultiWaveformWidget.ICON_NAME,
+                            tooltip="Add Multi Waveform",
+                            filled=True,
+                        ),
                         "image": MaterialIconAction(
                             icon_name=BECImageWidget.ICON_NAME, tooltip="Add Image", filled=True
                         ),
@@ -154,6 +160,9 @@ class BECDockArea(BECWidget, QWidget):
         self.toolbar.widgets["menu_plots"].widgets["waveform"].triggered.connect(
             lambda: self.add_dock(widget="BECWaveformWidget", prefix="waveform")
         )
+        self.toolbar.widgets["menu_plots"].widgets["multi_waveform"].triggered.connect(
+            lambda: self.add_dock(widget="BECMultiWaveformWidget", prefix="multi_waveform")
+        )
         self.toolbar.widgets["menu_plots"].widgets["image"].triggered.connect(
             lambda: self.add_dock(widget="BECImageWidget", prefix="image")
         )

bec_widgets/widgets/figure/figure.py

@@ -11,6 +11,7 @@ from bec_lib.logger import bec_logger
 from pydantic import Field, ValidationError, field_validator
 from qtpy.QtCore import Signal as pyqtSignal
 from qtpy.QtWidgets import QWidget
+from tornado.gen import multi
 from typeguard import typechecked
 
 from bec_widgets.utils import ConnectionConfig, WidgetContainerUtils
@@ -18,6 +19,10 @@ from bec_widgets.utils.bec_widget import BECWidget
 from bec_widgets.utils.colors import apply_theme
 from bec_widgets.widgets.figure.plots.image.image import BECImageShow, ImageConfig
 from bec_widgets.widgets.figure.plots.motor_map.motor_map import BECMotorMap, MotorMapConfig
+from bec_widgets.widgets.figure.plots.multi_waveform.multi_waveform import (
+    BECMultiWaveform,
+    BECMultiWaveformConfig,
+)
 from bec_widgets.widgets.figure.plots.plot_base import BECPlotBase, SubplotConfig
 from bec_widgets.widgets.figure.plots.waveform.waveform import BECWaveform, Waveform1DConfig
 
@@ -64,6 +69,7 @@ class WidgetHandler:
             "BECWaveform": (BECWaveform, Waveform1DConfig),
             "BECImageShow": (BECImageShow, ImageConfig),
             "BECMotorMap": (BECMotorMap, MotorMapConfig),
+            "BECMultiWaveform": (BECMultiWaveform, BECMultiWaveformConfig),
         }
 
     def create_widget(
@@ -134,8 +140,14 @@ class BECFigure(BECWidget, pg.GraphicsLayoutWidget):
         "BECWaveform": BECWaveform,
         "BECImageShow": BECImageShow,
         "BECMotorMap": BECMotorMap,
+        "BECMultiWaveform": BECMultiWaveform,
+    }
+    widget_method_map = {
+        "BECWaveform": "plot",
+        "BECImageShow": "image",
+        "BECMotorMap": "motor_map",
+        "BECMultiWaveform": "multi_waveform",
     }
-    widget_method_map = {"BECWaveform": "plot", "BECImageShow": "image", "BECMotorMap": "motor_map"}
 
     clean_signal = pyqtSignal()
 
@@ -445,10 +457,27 @@ class BECFigure(BECWidget, pg.GraphicsLayoutWidget):
 
         return motor_map
 
+    def multi_waveform(
+        self,
+        monitor: str = None,
+        new: bool = False,
+        row: int | None = None,
+        col: int | None = None,
+        config: dict | None = None,
+        **axis_kwargs,
+    ):
+        multi_waveform = self.subplot_factory(
+            widget_type="BECMultiWaveform", config=config, row=row, col=col, new=new, **axis_kwargs
+        )
+        if config is not None:
+            return multi_waveform
+        multi_waveform.set_monitor(monitor)
+        return multi_waveform
+
     def subplot_factory(
         self,
         widget_type: Literal[
-            "BECPlotBase", "BECWaveform", "BECImageShow", "BECMotorMap"
+            "BECPlotBase", "BECWaveform", "BECImageShow", "BECMotorMap", "BECMultiWaveform"
         ] = "BECPlotBase",
         row: int = None,
         col: int = None,
@@ -500,7 +529,7 @@ class BECFigure(BECWidget, pg.GraphicsLayoutWidget):
     def add_widget(
         self,
         widget_type: Literal[
-            "BECPlotBase", "BECWaveform", "BECImageShow", "BECMotorMap"
+            "BECPlotBase", "BECWaveform", "BECImageShow", "BECMotorMap", "BECMultiWaveform"
         ] = "BECPlotBase",
         widget_id: str = None,
         row: int = None,

bec_widgets/widgets/figure/plots/multi_waveform/multi_waveform.py

@@ -0,0 +1,353 @@
+from collections import deque
+from typing import Literal, Optional
+
+import pyqtgraph as pg
+from bec_lib.endpoints import MessageEndpoints
+from bec_lib.logger import bec_logger
+from pydantic import Field, field_validator
+from pyqtgraph.exporters import MatplotlibExporter
+from qtpy.QtCore import Signal, Slot
+from qtpy.QtWidgets import QWidget
+
+from bec_widgets.utils import Colors
+from bec_widgets.widgets.figure.plots.plot_base import BECPlotBase, SubplotConfig
+
+logger = bec_logger.logger
+
+
+class BECMultiWaveformConfig(SubplotConfig):
+    color_palette: Optional[str] = Field(
+        "magma", description="The color palette of the figure widget.", validate_default=True
+    )
+    curve_limit: Optional[int] = Field(
+        200, description="The maximum number of curves to display on the plot."
+    )
+    flush_buffer: Optional[bool] = Field(
+        False, description="Flush the buffer of the plot widget when the curve limit is reached."
+    )
+    monitor: Optional[str] = Field(
+        None, description="The monitor to set for the plot widget."
+    )  # TODO validate monitor in bec -> maybe make it as SignalData class for validation purpose
+    curve_width: Optional[int] = Field(1, description="The width of the curve on the plot.")
+    opacity: Optional[int] = Field(50, description="The opacity of the curve on the plot.")
+    highlight_last_curve: Optional[bool] = Field(
+        True, description="Highlight the last curve on the plot."
+    )
+
+    model_config: dict = {"validate_assignment": True}
+    _validate_color_map_z = field_validator("color_palette")(Colors.validate_color_map)
+
+
+class BECMultiWaveform(BECPlotBase):
+    monitor_signal_updated = Signal()
+    highlighted_curve_index_changed = Signal(int)
+    USER_ACCESS = [
+        "_rpc_id",
+        "_config_dict",
+        "curves",
+        "set_monitor",
+        "set_opacity",
+        "set_curve_limit",
+        "set_curve_highlight",
+        "set_colormap",
+        "set",
+        "set_title",
+        "set_x_label",
+        "set_y_label",
+        "set_x_scale",
+        "set_y_scale",
+        "set_x_lim",
+        "set_y_lim",
+        "set_grid",
+        "set_colormap",
+        "enable_fps_monitor",
+        "lock_aspect_ratio",
+        "export",
+        "get_all_data",
+        "remove",
+    ]
+
+    def __init__(
+        self,
+        parent: Optional[QWidget] = None,
+        parent_figure=None,
+        config: Optional[BECMultiWaveformConfig] = None,
+        client=None,
+        gui_id: Optional[str] = None,
+    ):
+        if config is None:
+            config = BECMultiWaveformConfig(widget_class=self.__class__.__name__)
+        super().__init__(
+            parent=parent, parent_figure=parent_figure, config=config, client=client, gui_id=gui_id
+        )
+        self.old_scan_id = None
+        self.scan_id = None
+        self.monitor = None
+        self.connected = False
+        self.current_highlight_index = 0
+        self._curves = deque()
+        self.visible_curves = []
+        self.number_of_visible_curves = 0
+
+        # Get bec shortcuts dev, scans, queue, scan_storage, dap
+        self.get_bec_shortcuts()
+
+    @property
+    def curves(self) -> deque:
+        """
+        Get the curves of the plot widget as a deque.
+        Returns:
+            deque: Deque of curves.
+        """
+        return self._curves
+
+    @curves.setter
+    def curves(self, value: deque):
+        self._curves = value
+
+    @property
+    def highlight_last_curve(self) -> bool:
+        """
+        Get the highlight_last_curve property.
+        Returns:
+            bool: The highlight_last_curve property.
+        """
+        return self.config.highlight_last_curve
+
+    @highlight_last_curve.setter
+    def highlight_last_curve(self, value: bool):
+        self.config.highlight_last_curve = value
+
+    def set_monitor(self, monitor: str):
+        """
+        Set the monitor for the plot widget.
+        Args:
+            monitor (str): The monitor to set.
+        """
+        self.config.monitor = monitor
+        self._connect_monitor()
+
+    def _connect_monitor(self):
+        """
+        Connect the monitor to the plot widget.
+        """
+        try:
+            previous_monitor = self.monitor
+        except AttributeError:
+            previous_monitor = None
+
+        if previous_monitor and self.connected is True:
+            self.bec_dispatcher.disconnect_slot(
+                self.on_monitor_1d_update, MessageEndpoints.device_monitor_1d(previous_monitor)
+            )
+        if self.config.monitor and self.connected is False:
+            self.bec_dispatcher.connect_slot(
+                self.on_monitor_1d_update, MessageEndpoints.device_monitor_1d(self.config.monitor)
+            )
+            self.connected = True
+            self.monitor = self.config.monitor
+
+    @Slot(dict, dict)
+    def on_monitor_1d_update(self, msg: dict, metadata: dict):
+        """
+        Update the plot widget with the monitor data.
+
+        Args:
+            msg(dict): The message data.
+            metadata(dict): The metadata of the message.
+        """
+        data = msg.get("data", None)
+        current_scan_id = metadata.get("scan_id", None)
+
+        if current_scan_id != self.scan_id:
+            self.scan_id = current_scan_id
+            self.clear_curves()
+            self.curves.clear()
+            if self.crosshair:
+                self.crosshair.clear_markers()
+
+        # Always create a new curve and add it
+        curve = pg.PlotDataItem()
+        curve.setData(data)
+        self.plot_item.addItem(curve)
+        self.curves.append(curve)
+
+        # Max Trace and scale colors
+        self.set_curve_limit(self.config.curve_limit, self.config.flush_buffer)
+
+        self.monitor_signal_updated.emit()
+
+    @Slot(int)
+    def set_curve_highlight(self, index: int):
+        """
+        Set the curve highlight based on visible curves.
+
+        Args:
+            index (int): The index of the curve to highlight among visible curves.
+        """
+        self.plot_item.visible_curves = [curve for curve in self.curves if curve.isVisible()]
+        num_visible_curves = len(self.plot_item.visible_curves)
+        self.number_of_visible_curves = num_visible_curves
+
+        if num_visible_curves == 0:
+            return  # No curves to highlight
+
+        if index >= num_visible_curves:
+            index = num_visible_curves - 1
+        elif index < 0:
+            index = num_visible_curves + index
+        self.current_highlight_index = index
+        num_colors = num_visible_curves
+        colors = Colors.evenly_spaced_colors(
+            colormap=self.config.color_palette, num=num_colors, format="HEX"
+        )
+        for i, curve in enumerate(self.plot_item.visible_curves):
+            curve.setPen()
+            if i == self.current_highlight_index:
+                curve.setPen(pg.mkPen(color=colors[i], width=5))
+                curve.setAlpha(alpha=1, auto=False)
+                curve.setZValue(1)
+            else:
+                curve.setPen(pg.mkPen(color=colors[i], width=1))
+                curve.setAlpha(alpha=self.config.opacity / 100, auto=False)
+                curve.setZValue(0)
+
+        self.highlighted_curve_index_changed.emit(self.current_highlight_index)
+
+    @Slot(int)
+    def set_opacity(self, opacity: int):
+        """
+        Set the opacity of the curve on the plot.
+
+        Args:
+            opacity(int): The opacity of the curve. 0-100.
+        """
+        self.config.opacity = max(0, min(100, opacity))
+        self.set_curve_highlight(self.current_highlight_index)
+
+    @Slot(int, bool)
+    def set_curve_limit(self, max_trace: int, flush_buffer: bool = False):
+        """
+        Set the maximum number of traces to display on the plot.
+
+        Args:
+            max_trace (int): The maximum number of traces to display.
+            flush_buffer (bool): Flush the buffer.
+        """
+        self.config.curve_limit = max_trace
+        self.config.flush_buffer = flush_buffer
+
+        if self.config.curve_limit is None:
+            self.scale_colors()
+            return
+
+        if self.config.flush_buffer:
+            # Remove excess curves from the plot and the deque
+            while len(self.curves) > self.config.curve_limit:
+                curve = self.curves.popleft()
+                self.plot_item.removeItem(curve)
+        else:
+            # Hide or show curves based on the new max_trace
+            num_curves_to_show = min(self.config.curve_limit, len(self.curves))
+            for i, curve in enumerate(self.curves):
+                if i < len(self.curves) - num_curves_to_show:
+                    curve.hide()
+                else:
+                    curve.show()
+        self.scale_colors()
+
+    def scale_colors(self):
+        """
+        Scale the colors of the curves based on the current colormap.
+        """
+        if self.config.highlight_last_curve:
+            self.set_curve_highlight(-1)  # Use -1 to highlight the last visible curve
+        else:
+            self.set_curve_highlight(self.current_highlight_index)
+
+    def set_colormap(self, colormap: str):
+        """
+        Set the colormap for the curves.
+
+        Args:
+            colormap(str): Colormap for the curves.
+        """
+        self.config.color_palette = colormap
+        self.set_curve_highlight(self.current_highlight_index)
+
+    def hook_crosshair(self) -> None:
+        super().hook_crosshair()
+        if self.crosshair:
+            self.highlighted_curve_index_changed.connect(self.crosshair.update_highlighted_curve)
+            if self.curves:
+                self.crosshair.update_highlighted_curve(self.current_highlight_index)
+
+    def get_all_data(self, output: Literal["dict", "pandas"] = "dict") -> dict:
+        """
+        Extract all curve data into a dictionary or a pandas DataFrame.
+
+        Args:
+            output (Literal["dict", "pandas"]): Format of the output data.
+
+        Returns:
+            dict | pd.DataFrame: Data of all curves in the specified format.
+        """
+        data = {}
+        try:
+            import pandas as pd
+        except ImportError:
+            pd = None
+            if output == "pandas":
+                logger.warning(
+                    "Pandas is not installed. "
+                    "Please install pandas using 'pip install pandas'."
+                    "Output will be dictionary instead."
+                )
+                output = "dict"
+
+        curve_keys = []
+        curves_list = list(self.curves)
+        for i, curve in enumerate(curves_list):
+            x_data, y_data = curve.getData()
+            if x_data is not None or y_data is not None:
+                key = f"curve_{i}"
+                curve_keys.append(key)
+                if output == "dict":
+                    data[key] = {"x": x_data.tolist(), "y": y_data.tolist()}
+                elif output == "pandas" and pd is not None:
+                    data[key] = pd.DataFrame({"x": x_data, "y": y_data})
+
+        if output == "pandas" and pd is not None:
+            combined_data = pd.concat([data[key] for key in curve_keys], axis=1, keys=curve_keys)
+            return combined_data
+        return data
+
+    def clear_curves(self):
+        """
+        Remove all curves from the plot, excluding crosshair items.
+        """
+        items_to_remove = []
+        for item in self.plot_item.items:
+            if not getattr(item, "is_crosshair", False) and isinstance(item, pg.PlotDataItem):
+                items_to_remove.append(item)
+        for item in items_to_remove:
+            self.plot_item.removeItem(item)
+
+    def export_to_matplotlib(self):
+        """
+        Export current waveform to matplotlib GUI. Available only if matplotlib is installed in the environment.
+        """
+        MatplotlibExporter(self.plot_item).export()
+
+
+if __name__ == "__main__":
+    import sys
+
+    from qtpy.QtWidgets import QApplication
+
+    from bec_widgets.widgets.figure import BECFigure
+
+    app = QApplication(sys.argv)
+    widget = BECFigure()
+    widget.show()
+    sys.exit(app.exec_())

bec_widgets/widgets/multi_waveform/bec_multi_waveform_widget.pyproject

@@ -0,0 +1 @@
+{'files': ['multi_waveform_widget.py','multi-waveform_controls.ui']}