bec-widgets 0.76.0__py3-none-any.whl → 0.77.0__py3-none-any.whl

bec_widgets/widgets/figure/plots/image/image.py

@@ -5,7 +5,7 @@ from typing import Any, Literal, Optional
 
 import numpy as np
 from bec_lib.endpoints import MessageEndpoints
-from pydantic import Field, ValidationError
+from pydantic import BaseModel, Field, ValidationError
 from qtpy.QtCore import QThread
 from qtpy.QtCore import Slot as pyqtSlot
 from qtpy.QtWidgets import QWidget
@@ -29,11 +29,9 @@ class ImageConfig(SubplotConfig):
 
 class BECImageShow(BECPlotBase):
     USER_ACCESS = [
-        "rpc_id",
-        "config_dict",
+        "_rpc_id",
+        "_config_dict",
         "add_image_by_config",
-        "get_image_config",
-        "get_image_dict",
         "add_monitor_image",
         "add_custom_image",
         "set_vrange",
@@ -47,7 +45,6 @@ class BECImageShow(BECPlotBase):
         "set_log",
         "set_rotation",
         "set_transpose",
-        "toggle_threading",
         "set",
         "set_title",
         "set_x_label",
@@ -138,7 +135,8 @@ class BECImageShow(BECPlotBase):
         self.apply_axis_config()
         self._images = defaultdict(dict)
 
-        # TODO extend by adding image by config
+        for image_id, image_config in config.images.items():
+            self.add_image_by_config(image_config)
 
     def change_gui_id(self, new_gui_id: str):
         """
@@ -226,7 +224,7 @@ class BECImageShow(BECPlotBase):
         self,
         monitor: str,
         color_map: Optional[str] = "magma",
-        color_bar: Optional[Literal["simple", "full"]] = "simple",
+        color_bar: Optional[Literal["simple", "full"]] = "full",
         downsample: Optional[bool] = True,
         opacity: Optional[float] = 1.0,
         vrange: Optional[tuple[int, int]] = None,
@@ -241,7 +239,7 @@ class BECImageShow(BECPlotBase):
                 f"Monitor with ID '{monitor}' already exists in widget '{self.gui_id}'."
             )
 
-        monitor = self.entry_validator.validate_monitor(monitor)
+        # monitor = self.entry_validator.validate_monitor(monitor)
 
         image_config = ImageItemConfig(
             widget_class="BECImageItem",
@@ -251,12 +249,13 @@ class BECImageShow(BECPlotBase):
             downsample=downsample,
             opacity=opacity,
             vrange=vrange,
+            source=image_source,
+            monitor=monitor,
             # post_processing=post_processing,
             **kwargs,
         )
 
         image = self._add_image_object(source=image_source, name=monitor, config=image_config)
-        self._connect_device_monitor(monitor)
         return image
 
     def add_custom_image(
@@ -264,16 +263,17 @@ class BECImageShow(BECPlotBase):
         name: str,
         data: Optional[np.ndarray] = None,
         color_map: Optional[str] = "magma",
-        color_bar: Optional[Literal["simple", "full"]] = "simple",
+        color_bar: Optional[Literal["simple", "full"]] = "full",
         downsample: Optional[bool] = True,
         opacity: Optional[float] = 1.0,
         vrange: Optional[tuple[int, int]] = None,
         # post_processing: Optional[PostProcessingConfig] = None,
         **kwargs,
     ):
-        image_source = "device_monitor"
+        image_source = "custom"
+        # image_source = "device_monitor"
 
-        image_exits = self._check_curve_id(name, self._images)
+        image_exits = self._check_image_id(name, self._images)
         if image_exits:
             raise ValueError(f"Monitor with ID '{name}' already exists in widget '{self.gui_id}'.")
 
@@ -290,7 +290,9 @@ class BECImageShow(BECPlotBase):
             **kwargs,
         )
 
-        image = self._add_image_object(source=image_source, config=image_config, data=data)
+        image = self._add_image_object(
+            source=image_source, name=name, config=image_config, data=data
+        )
         return image
 
     def apply_setting_to_images(
@@ -313,6 +315,7 @@ class BECImageShow(BECPlotBase):
             for source, images in self._images.items():
                 for _, image in images.items():
                     getattr(image, setting_method_name)(*args, **kwargs)
+        self.refresh_image()
 
     def set_vrange(self, vmin: float, vmax: float, name: str = None):
         """
@@ -460,18 +463,19 @@ class BECImageShow(BECPlotBase):
         if self.use_threading is False and self.thread.isRunning():
             self.cleanup()
 
-    @pyqtSlot(dict)
-    def on_image_update(self, msg: dict):
+    def process_image(self, device: str, image: BECImageItem, data: np.ndarray):
         """
-        Update the image of the device monitor from bec.
+        Process the image data.
 
         Args:
-            msg(dict): The message from bec.
+            device(str): The name of the device - image_id of image.
+            image(np.ndarray): The image data to be processed.
+            data(np.ndarray): The image data to be processed.
+
+        Returns:
+            np.ndarray: The processed image data.
         """
-        data = msg["data"]
-        device = msg["device"]
-        image_to_update = self._images["device_monitor"][device]
-        processing_config = image_to_update.config.processing
+        processing_config = image.config.processing
         self.processor.set_config(processing_config)
         if self.use_threading:
             self._create_thread_worker(device, data)
@@ -480,6 +484,19 @@ class BECImageShow(BECPlotBase):
             self.update_image(device, data)
             self.update_vrange(device, self.processor.config.stats)
 
+    @pyqtSlot(dict)
+    def on_image_update(self, msg: dict):
+        """
+        Update the image of the device monitor from bec.
+
+        Args:
+            msg(dict): The message from bec.
+        """
+        data = msg["data"]
+        device = msg["device"]
+        image = self._images["device_monitor"][device]
+        self.process_image(device, image, data)
+
     @pyqtSlot(str, np.ndarray)
     def update_image(self, device: str, data: np.ndarray):
         """
@@ -504,6 +521,15 @@ class BECImageShow(BECPlotBase):
         if image_to_update.config.autorange:
             image_to_update.auto_update_vrange(stats)
 
+    def refresh_image(self):
+        """
+        Refresh the image.
+        """
+        for source, images in self._images.items():
+            for image_id, image in images.items():
+                data = image.get_data()
+                self.process_image(image_id, image, data)
+
     def _connect_device_monitor(self, monitor: str):
         """
         Connect to the device monitor.
@@ -516,16 +542,18 @@ class BECImageShow(BECPlotBase):
             previous_monitor = image_item.config.monitor
         except AttributeError:
             previous_monitor = None
-        if previous_monitor != monitor:
-            if previous_monitor:
-                self.bec_dispatcher.disconnect_slot(
-                    self.on_image_update, MessageEndpoints.device_monitor(previous_monitor)
-                )
-            if monitor:
-                self.bec_dispatcher.connect_slot(
-                    self.on_image_update, MessageEndpoints.device_monitor(monitor)
-                )
-                image_item.set_monitor(monitor)
+        if previous_monitor and image_item.connected is True:
+            self.bec_dispatcher.disconnect_slot(
+                self.on_image_update, MessageEndpoints.device_monitor(previous_monitor)
+            )
+            image_item.connected = False
+        if monitor and image_item.connected is False:
+            self.entry_validator.validate_monitor(monitor)
+            self.bec_dispatcher.connect_slot(
+                self.on_image_update, MessageEndpoints.device_monitor(monitor)
+            )
+            image_item.set_monitor(monitor)
+            image_item.connected = True
 
     def _add_image_object(
         self, source: str, name: str, config: ImageItemConfig, data=None
@@ -534,6 +562,8 @@ class BECImageShow(BECPlotBase):
         image = BECImageItem(config=config, parent_image=self)
         self.plot_item.addItem(image)
         self._images[source][name] = image
+        if source == "device_monitor":
+            self._connect_device_monitor(config.monitor)
         self.config.images[name] = config
         if data is not None:
             image.setImage(data)
@@ -558,23 +588,6 @@ class BECImageShow(BECPlotBase):
                     return True
         return False
 
-    def _validate_monitor(self, monitor: str, validate_bec: bool = True):
-        """
-        Validate the monitor name.
-
-        Args:
-            monitor(str): The name of the monitor.
-            validate_bec(bool): Whether to validate the monitor name with BEC.
-
-        Returns:
-            bool: True if the monitor name is valid, False otherwise.
-        """
-        if not monitor or monitor == "":
-            return False
-        if validate_bec:
-            return monitor in self.dev
-        return True
-
     def cleanup(self):
         """
         Clean up the widget.

bec_widgets/widgets/figure/plots/image/image_item.py

@@ -20,7 +20,7 @@ class ImageItemConfig(ConnectionConfig):
     color_map: Optional[str] = Field("magma", description="The color map of the image.")
     downsample: Optional[bool] = Field(True, description="Whether to downsample the image.")
     opacity: Optional[float] = Field(1.0, description="The opacity of the image.")
-    vrange: Optional[tuple[float, float]] = Field(
+    vrange: Optional[tuple[float | int, float | int]] = Field(
         None, description="The range of the color bar. If None, the range is automatically set."
     )
     color_bar: Optional[Literal["simple", "full"]] = Field(
@@ -37,8 +37,8 @@ class ImageItemConfig(ConnectionConfig):
 
 class BECImageItem(BECConnector, pg.ImageItem):
     USER_ACCESS = [
-        "rpc_id",
-        "config_dict",
+        "_rpc_id",
+        "_config_dict",
         "set",
         "set_fft",
         "set_log",
@@ -78,6 +78,7 @@ class BECImageItem(BECConnector, pg.ImageItem):
         self.apply_config()
         if kwargs:
             self.set(**kwargs)
+        self.connected = False
 
     def apply_config(self):
         """

bec_widgets/widgets/figure/plots/motor_map/motor_map.py

@@ -6,22 +6,23 @@ from typing import Optional, Union
 import numpy as np
 import pyqtgraph as pg
 from bec_lib.endpoints import MessageEndpoints
-from pydantic import Field
+from pydantic import Field, ValidationError, field_validator
+from pydantic_core import PydanticCustomError
 from qtpy import QtCore, QtGui
 from qtpy.QtCore import Signal as pyqtSignal
 from qtpy.QtCore import Slot as pyqtSlot
 from qtpy.QtWidgets import QWidget
 
-from bec_widgets.utils import EntryValidator
+from bec_widgets.utils import Colors, EntryValidator
 from bec_widgets.widgets.figure.plots.plot_base import BECPlotBase, SubplotConfig
 from bec_widgets.widgets.figure.plots.waveform.waveform import Signal, SignalData
 
 
 class MotorMapConfig(SubplotConfig):
     signals: Optional[Signal] = Field(None, description="Signals of the motor map")
-    color_map: Optional[str] = Field(
-        "Greys", description="Color scheme of the motor position gradient."
-    )  # TODO decide if useful for anything, or just keep GREYS always
+    color: Optional[str | tuple] = Field(
+        (255, 255, 255, 255), description="The color of the last point of current position."
+    )
     scatter_size: Optional[int] = Field(5, description="Size of the scatter points.")
     max_points: Optional[int] = Field(1000, description="Maximum number of points to display.")
     num_dim_points: Optional[int] = Field(
@@ -30,14 +31,26 @@ class MotorMapConfig(SubplotConfig):
     )
     precision: Optional[int] = Field(2, description="Decimal precision of the motor position.")
     background_value: Optional[int] = Field(
-        25, description="Background value of the motor map."
-    )  # TODO can be percentage from 255 calculated
+        25, description="Background value of the motor map. Has to be between 0 and 255."
+    )
+
+    model_config: dict = {"validate_assignment": True}
+
+    _validate_color = field_validator("color")(Colors.validate_color)
+
+    @field_validator("background_value")
+    def validate_background_value(cls, value):
+        if not 0 <= value <= 255:
+            raise PydanticCustomError(
+                "wrong_value", f"'{value}' hs to be between 0 and 255.", {"wrong_value": value}
+            )
+        return value
 
 
 class BECMotorMap(BECPlotBase):
     USER_ACCESS = [
-        "rpc_id",
-        "config_dict",
+        "_rpc_id",
+        "_config_dict",
         "change_motors",
         "set_max_points",
         "set_precision",
@@ -69,29 +82,43 @@ class BECMotorMap(BECPlotBase):
         self.get_bec_shortcuts()
         self.entry_validator = EntryValidator(self.dev)
 
+        # connect update signal to update plot
+        self.proxy_update_plot = pg.SignalProxy(
+            self.update_signal, rateLimit=25, slot=self._update_plot
+        )
+        self.apply_config(self.config)
+
+    def apply_config(self, config: dict | MotorMapConfig):
+        """
+        Apply the config to the motor map.
+
+        Args:
+            config(dict|MotorMapConfig): Config to be applied.
+        """
+        if isinstance(config, dict):
+            try:
+                config = MotorMapConfig(**config)
+            except ValidationError as e:
+                print(f"Error in applying config: {e}")
+                return
+
+        self.config = config
+        self.plot_item.clear()
+
         self.motor_x = None
         self.motor_y = None
         self.database_buffer = {"x": [], "y": []}
         self.plot_components = defaultdict(dict)  # container for plot components
 
-        # connect update signal to update plot
-        self.proxy_update_plot = pg.SignalProxy(
-            self.update_signal, rateLimit=25, slot=self._update_plot
-        )
+        self.apply_axis_config()
 
-    # TODO decide if needed to implement, maybe there will be no children widgets for motormap for now...
-    # def find_widget_by_id(self, item_id: str) -> BECCurve:
-    #     """
-    #     Find the curve by its ID.
-    #     Args:
-    #         item_id(str): ID of the curve.
-    #
-    #     Returns:
-    #         BECCurve: The curve object.
-    #     """
-    #     for curve in self.plot_item.curves:
-    #         if curve.gui_id == item_id:
-    #             return curve
+        if self.config.signals is not None:
+            self.change_motors(
+                motor_x=self.config.signals.x.name,
+                motor_y=self.config.signals.y.name,
+                motor_x_entry=self.config.signals.x.entry,
+                motor_y_entry=self.config.signals.y.entry,
+            )
 
     @pyqtSlot(str, str, str, str, bool)
     def change_motors(
@@ -129,6 +156,8 @@ class BECMotorMap(BECPlotBase):
         # reconnect the signals
         self._connect_motor_to_slots()
 
+        self.database_buffer = {"x": [], "y": []}
+
         # Redraw the motor map
         self._make_motor_map()
 
@@ -141,7 +170,19 @@ class BECMotorMap(BECPlotBase):
         data = {"x": self.database_buffer["x"], "y": self.database_buffer["y"]}
         return data
 
-    # TODO setup all visual properties
+    def set_color(self, color: [str | tuple]):
+        """
+        Set color of the motor trace.
+
+        Args:
+            color(str|tuple): Color of the motor trace. Can be HEX(str) or RGBA(tuple).
+        """
+        if isinstance(color, str):
+            color = Colors.validate_color(color)
+            color = Colors.hex_to_rgba(color, 255)
+        self.config.color = color
+        self.update_signal.emit()
+
     def set_max_points(self, max_points: int) -> None:
         """
         Set the maximum number of points to display.
@@ -150,6 +191,7 @@ class BECMotorMap(BECPlotBase):
             max_points(int): Maximum number of points to display.
         """
         self.config.max_points = max_points
+        self.update_signal.emit()
 
     def set_precision(self, precision: int) -> None:
         """
@@ -159,6 +201,7 @@ class BECMotorMap(BECPlotBase):
             precision(int): Decimal precision of the motor position.
         """
         self.config.precision = precision
+        self.update_signal.emit()
 
     def set_num_dim_points(self, num_dim_points: int) -> None:
         """
@@ -168,6 +211,7 @@ class BECMotorMap(BECPlotBase):
             num_dim_points(int): Number of dim points.
         """
         self.config.num_dim_points = num_dim_points
+        self.update_signal.emit()
 
     def set_background_value(self, background_value: int) -> None:
         """
@@ -177,6 +221,7 @@ class BECMotorMap(BECPlotBase):
             background_value(int): Background value of the motor map.
         """
         self.config.background_value = background_value
+        self._swap_limit_map()
 
     def set_scatter_size(self, scatter_size: int) -> None:
         """
@@ -186,6 +231,7 @@ class BECMotorMap(BECPlotBase):
             scatter_size(int): Size of the scatter points.
         """
         self.config.scatter_size = scatter_size
+        self.update_signal.emit()
 
     def _disconnect_current_motors(self):
         """Disconnect the current motors from the slots."""
@@ -210,6 +256,15 @@ class BECMotorMap(BECPlotBase):
 
         self.bec_dispatcher.connect_slot(self.on_device_readback, endpoints)
 
+    def _swap_limit_map(self):
+        """Swap the limit map."""
+        self.plot_item.removeItem(self.plot_components["limit_map"])
+        self.plot_components["limit_map"] = self._make_limit_map(
+            self.config.signals.x.limits, self.config.signals.y.limits
+        )
+        self.plot_components["limit_map"].setZValue(-1)
+        self.plot_item.addItem(self.plot_components["limit_map"])
+
     def _make_motor_map(self):
         """
         Create the motor map plot.
@@ -249,6 +304,8 @@ class BECMotorMap(BECPlotBase):
         # Set default labels for the plot
         self.set(x_label=f"Motor X ({self.motor_x})", y_label=f"Motor Y ({self.motor_y})")
 
+        self.update_signal.emit()
+
     def _add_coordinantes_crosshair(self, x: float, y: float) -> None:
         """
         Add crosshair to the plot to highlight the current position.
@@ -373,19 +430,31 @@ class BECMotorMap(BECPlotBase):
 
     def _update_plot(self):
         """Update the motor map plot."""
+        # If the number of points exceeds max_points, delete the oldest points
+        if len(self.database_buffer["x"]) > self.config.max_points:
+            self.database_buffer["x"] = self.database_buffer["x"][-self.config.max_points :]
+            self.database_buffer["y"] = self.database_buffer["y"][-self.config.max_points :]
+
         x = self.database_buffer["x"]
         y = self.database_buffer["y"]
 
         # Setup gradient brush for history
         brushes = [pg.mkBrush(50, 50, 50, 255)] * len(x)
 
+        # RGB color
+        r, g, b, a = self.config.color
+
         # Calculate the decrement step based on self.num_dim_points
         num_dim_points = self.config.num_dim_points
         decrement_step = (255 - 50) / num_dim_points
+
         for i in range(1, min(num_dim_points + 1, len(x) + 1)):
             brightness = max(60, 255 - decrement_step * (i - 1))
-            brushes[-i] = pg.mkBrush(brightness, brightness, brightness, 255)
-        brushes[-1] = pg.mkBrush(255, 255, 255, 255)  # Newest point is always full brightness
+            dim_r = int(r * (brightness / 255))
+            dim_g = int(g * (brightness / 255))
+            dim_b = int(b * (brightness / 255))
+            brushes[-i] = pg.mkBrush(dim_r, dim_g, dim_b, a)
+        brushes[-1] = pg.mkBrush(r, g, b, a)  # Newest point is always full brightness
         scatter_size = self.config.scatter_size
 
         # Update the scatter plot

bec_widgets/widgets/figure/plots/plot_base.py

@@ -46,7 +46,7 @@ class SubplotConfig(ConnectionConfig):
 
 class BECPlotBase(BECConnector, pg.GraphicsLayout):
     USER_ACCESS = [
-        "config_dict",
+        "_config_dict",
         "set",
         "set_title",
         "set_x_label",

bec_widgets/widgets/figure/plots/waveform/waveform.py

@@ -35,8 +35,8 @@ class Waveform1DConfig(SubplotConfig):
 
 class BECWaveform(BECPlotBase):
     USER_ACCESS = [
-        "rpc_id",
-        "config_dict",
+        "_rpc_id",
+        "_config_dict",
         "plot",
         "add_dap",
         "get_dap_params",
@@ -44,8 +44,6 @@ class BECWaveform(BECPlotBase):
         "scan_history",
         "curves",
         "get_curve",
-        "get_curve_config",
-        "apply_config",
         "get_all_data",
         "set",
         "set_title",
@@ -705,14 +703,15 @@ class BECWaveform(BECPlotBase):
                 data_y = data[y_name][y_entry].val
                 if curve.config.signals.z:
                     data_z = data[z_name][z_entry].val
-                    color_z = self._make_z_gradient(
-                        data_z, curve.config.color_map_z
-                    )  # TODO decide how to implement custom gradient
+                    color_z = self._make_z_gradient(data_z, curve.config.color_map_z)
             except TypeError:
                 continue
 
             if data_z is not None and color_z is not None:
-                curve.setData(x=data_x, y=data_y, symbolBrush=color_z)
+                try:
+                    curve.setData(x=data_x, y=data_y, symbolBrush=color_z)
+                except:
+                    return
             else:
                 curve.setData(data_x, data_y)
 

bec_widgets/widgets/figure/plots/waveform/waveform_curve.py

@@ -65,8 +65,8 @@ class BECCurve(BECConnector, pg.PlotDataItem):
     USER_ACCESS = [
         "remove",
         "dap_params",
-        "rpc_id",
-        "config_dict",
+        "_rpc_id",
+        "_config_dict",
         "set",
         "set_data",
         "set_color",

bec_widgets/widgets/ring_progress_bar/ring.py

@@ -79,9 +79,9 @@ class RingConfig(ProgressbarConfig):
 
 class Ring(BECConnector):
     USER_ACCESS = [
-        "get_all_rpc",
-        "rpc_id",
-        "config_dict",
+        "_get_all_rpc",
+        "_rpc_id",
+        "_config_dict",
         "set_value",
         "set_color",
         "set_background",

bec_widgets/widgets/ring_progress_bar/ring_progress_bar.py

@@ -68,9 +68,9 @@ class RingProgressBarConfig(ConnectionConfig):
 
 class RingProgressBar(BECConnector, QWidget):
     USER_ACCESS = [
-        "get_all_rpc",
-        "rpc_id",
-        "config_dict",
+        "_get_all_rpc",
+        "_rpc_id",
+        "_config_dict",
         "rings",
         "update_config",
         "add_ring",

{bec_widgets-0.76.0.dist-info → bec_widgets-0.77.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: bec_widgets
-Version: 0.76.0
+Version: 0.77.0
 Summary: BEC Widgets
 Project-URL: Bug Tracker, https://gitlab.psi.ch/bec/bec_widgets/issues
 Project-URL: Homepage, https://gitlab.psi.ch/bec/bec_widgets
@@ -16,6 +16,7 @@ Requires-Dist: isort>=5.13.2,~=5.13
 Requires-Dist: pydantic~=2.0
 Requires-Dist: pyqtdarktheme~=2.1
 Requires-Dist: pyqtgraph~=0.13
+Requires-Dist: pyte
 Requires-Dist: qtconsole>=5.5.1,~=5.5
 Requires-Dist: qtpy~=2.4
 Provides-Extra: dev