pymodaq 4.1.5__py3-none-any.whl → 4.2.1__py3-none-any.whl

pymodaq/utils/plotting/data_viewers/viewer1D.py

@@ -1,7 +1,7 @@
 import sys
 import datetime
 from collections import OrderedDict
-from typing import List, Iterable
+from typing import List, Iterable, Union, Dict, Tuple
 
 from qtpy import QtWidgets
 from qtpy.QtCore import QObject, Slot, Signal, Qt, QRectF
@@ -16,44 +16,17 @@ from pymodaq.utils import daq_utils as utils
 import pymodaq.utils.math_utils as mutils
 from pymodaq.utils.managers.action_manager import ActionManager
 from pymodaq.utils.plotting.data_viewers.viewer import ViewerBase
-
+from pymodaq.utils.plotting.utils.plot_utils import make_dashed_pens, RoiInfo
 from pymodaq.utils.managers.roi_manager import ROIManager
 from pymodaq.utils.plotting.utils.filter import Filter1DFromCrosshair, Filter1DFromRois
-from pymodaq.utils.plotting.utils.lineout import LineoutPlotter
 from pymodaq.utils.plotting.widgets import PlotWidget
-
+from pymodaq.utils.plotting.data_viewers.viewer0D import Viewer0D
 
 logger = set_logger(get_module_name(__file__))
 
 PLOT_COLORS = utils.plot_colors
 
 
-class LineoutPlotter(LineoutPlotter):
-    """class to manage and display data filtered out into lineouts (1D, 0D)
-
-    Should be inherited and subclass some methods as appropriate
-
-    Parameters
-    ----------
-    graph_widgets: OrderedDict
-        Includes plotwidgets to display data
-    roi_manager:
-        The ROIManager to create ROIs and manage their properties
-    crosshair:
-        The Crosshair object
-    """
-    lineout_widgets = ['int']
-
-    def __init__(self, graph_widgets: OrderedDict, roi_manager: ROIManager, crosshair: Crosshair):
-        super().__init__(graph_widgets, roi_manager, crosshair)
-
-    def plot_other_lineouts(self, roi_dicts):
-        pass
-
-    def plot_other_crosshair_lineouts(self, crosshair_dict):
-        pass
-
-
 class DataDisplayer(QObject):
     """
     This Object deals with the display of 1D data  on a plotitem
@@ -62,14 +35,30 @@ class DataDisplayer(QObject):
     updated_item = Signal(list)
     labels_changed = Signal(list)
 
-    def __init__(self, plotitem: pg.PlotItem):
+    def __init__(self, plotitem: pg.PlotItem, flip_axes=False, plot_colors=PLOT_COLORS):
         super().__init__()
+        self._doxy = False
+        self._do_sort = False
+        self._do_scatter = False
+        self._show_errors = False
+        self._flip_axes = flip_axes
         self._plotitem = plotitem
         self._plotitem.addLegend()
         self._plot_items: List[pg.PlotDataItem] = []
+        self._boundary_items: List[Tuple[pg.PlotDataItem, pg.PlotDataItem]] = []
+        self._fill_items: List[pg.FillBetweenItem] = []
         self._overlay_items: List[pg.PlotDataItem] = []
         self._axis: Axis = None
-        self._data: DataRaw = None
+        self._data: DataWithAxes = None
+        self._plot_colors = plot_colors
+
+    @property
+    def Ndata(self):
+        return len(self._data) if self._data is not None else 0
+
+    def update_colors(self, colors: list):
+        self._plot_colors[0:len(colors)] = colors
+        self.update_data(self._data, force_update=True)
 
         self._doxy = False
         self._do_sort = False
@@ -92,94 +81,153 @@ class DataDisplayer(QObject):
     def get_plot_item(self, index: int):
         return self._plot_items[index]
 
-    def update_data(self, data: DataRaw, do_xy=False, sort_data=False):
-        self._data = data
-        if len(data) != len(self._plot_items):
-            self.update_display_items(data)
-        self.update_plot(do_xy, data, sort_data)
+    def update_data(self, data: DataRaw, do_xy=False, sort_data=False, force_update=False,
+                    do_scatter=False, show_errors=False):
+        if data is not None:
+            if data.labels != self.labels or self._show_errors != show_errors:
+                force_update = True
+            self._data = data
+            if len(data) != len(self._plot_items) or force_update:
+                self.update_display_items(data, show_errors)
+            self.update_plot(do_xy, data, sort_data, do_scatter, show_errors)
 
     def update_xy(self, do_xy=False):
         self._doxy = do_xy
-        self.update_plot(do_xy, sort_data=self._do_sort)
+        self.update_plot(do_xy, sort_data=self._do_sort, scatter=self._do_scatter)
 
     def update_sort(self, do_sort=False):
         self._do_sort = do_sort
-        self.update_plot(self._doxy, sort_data=self._do_sort)
+        self.update_plot(self._doxy, sort_data=self._do_sort, scatter=self._do_scatter)
 
-    def update_plot(self, do_xy=True, data=None, sort_data=False):
-        if data is None:
-            data = self._data
-        if sort_data:
-            data = data.sort_data()
+    def update_scatter(self, do_scatter=False):
+        self._do_scatter = do_scatter
+        self.update_plot(self._doxy, sort_data=self._do_sort, scatter=self._do_scatter)
 
-        axis = data.get_axis_from_index(0, create=False)[0]
-        if axis is not None:
-            self.update_axis(axis)
+    def update_errors(self, show_errors=False):
+        self._show_errors = show_errors
+        self.update_data(self._data, self._doxy, sort_data=self._do_sort, force_update=True,
+                         do_scatter=self._do_scatter, show_errors=show_errors)
 
-        self._doxy = do_xy
-        self._do_sort = sort_data
-
-        self.update_xyplot(do_xy, data)
-
-    def update_xyplot(self, do_xy=True, data=None):
+    def update_plot(self, do_xy=True, data=None, sort_data=False, scatter=False, show_errors=False):
         if data is None:
             data = self._data
-
-        for ind_data, dat in enumerate(data.data):
-            if data.size > 0:
+        if data is not None:
+            if sort_data:
+                data = data.sort_data()
+                if len(data.axes) == 0:
+                    data.create_missing_axes()
+            self._doxy = do_xy
+            self._do_sort = sort_data
+            self._show_errors = show_errors
+            self.update_xyplot(do_xy, data)
+
+            if scatter and self.get_plot_items()[0].opts['symbol'] is None:
+                if 'symbol_size' in data.extra_attributes:
+                    symbol_size = data.symbol_size
+                else:
+                    symbol_size = 5
+                if 'symbol' in data.extra_attributes:
+                    symbol = data.symbol
+                else:
+                    symbol = 'o'
+                if 'color' in data.extra_attributes:
+                    color = data.color
+                else:
+                    color = None
+                self.plot_with_scatter(True, symbol_size, symbol, color)
+            elif not scatter and self.get_plot_items()[0].opts['symbol'] is not None:
+                self.plot_with_scatter(False)
+
+    def update_xyplot(self, do_xy=True, dwa: DataWithAxes=None):
+        if dwa is None:
+            dwa = self._data
+        _axis = dwa.get_axis_from_index(0)[0]
+        _axis_array = _axis.get_data()
+        for ind_data, dat in enumerate(dwa.data):
+            if dwa.size > 0:
                 if not do_xy:
-                    if self._axis is None:
-                        self.update_axis(Axis('index', data=Axis.create_simple_linear_data(dat.size)))
-                    self._plot_items[ind_data].setData(self._axis.get_data(), dat)
+                    if self._flip_axes:
+                        self._plot_items[ind_data].setData(dat, _axis_array)
+                    else:
+                        self._plot_items[ind_data].setData(_axis_array, dat)
+                        if self._show_errors:
+                            self._boundary_items[ind_data][0].setData(
+                                _axis_array,
+                                dat + dwa.get_error(ind_data))
+                            self._boundary_items[ind_data][1].setData(
+                                _axis_array,
+                                dat - dwa.get_error(ind_data))
                 else:
                     self._plot_items[ind_data].setData(np.array([]), np.array([]))
 
-        if do_xy and len(data) == 2:
-            self._plot_items[0].setData(data.data[0], data.data[1])
-            axis = self._plotitem.getAxis('bottom')
-            axis.setLabel(text=data.labels[0], units='')
-            axis = self._plotitem.getAxis('left')
-            axis.setLabel(text=data.labels[1], units='')
-            self.legend.setVisible(False)
+        if do_xy:
+            for ind, data_array in enumerate(dwa[1:]):
+                self._plot_items[ind].setData(dwa.data[0], data_array)
+                axis = self._plotitem.getAxis('bottom')
+                axis.setLabel(text=dwa.labels[0], units='')
+                axis = self._plotitem.getAxis('left')
+                axis.setLabel(text=' / '.join(dwa.labels[1:]), units='')
+                self.legend.setVisible(False)
 
         else:
             axis = self._plotitem.getAxis('bottom')
-            axis.setLabel(text=self._axis.label, units=self._axis.units)
+            axis.setLabel(text=_axis.label, units=_axis.units)
             axis = self._plotitem.getAxis('left')
             axis.setLabel(text='', units='')
             self.legend.setVisible(True)
 
-    def plot_with_scatter(self, with_scatter=True):
-        symbol_size = 5
+    def plot_with_scatter(self, with_scatter=True, symbol_size=5, symbol='o', color=None):
+
         for ind, plot_item in enumerate(self.get_plot_items()):
+            if color is None:
+                color = self._plot_colors[ind]
             if with_scatter:
                 pen = None
-                symbol = 'o'
-                brush = PLOT_COLORS[ind]
+                symbol_type = symbol
+                brush = color
 
             else:
-                pen = PLOT_COLORS[ind]
-                symbol = None
+                pen = color
+                symbol_type = None
                 brush = None
 
             plot_item.setPen(pen)
             plot_item.setSymbolBrush(brush)
-            plot_item.setSymbol(symbol)
+            plot_item.setSymbol(symbol_type)
             plot_item.setSymbolSize(symbol_size)
 
-    def update_display_items(self, data: DataRaw):
+    def update_display_items(self, data: DataWithAxes = None, show_errors=False):
         while len(self._plot_items) > 0:
             self._plotitem.removeItem(self._plot_items.pop(0))
-        for ind in range(len(data)):
-            self._plot_items.append(pg.PlotDataItem(pen=PLOT_COLORS[ind]))
-            self._plotitem.addItem(self._plot_items[-1])
-            self.legend.addItem(self._plot_items[-1], data.labels[ind])
-        self.updated_item.emit(self._plot_items)
-        self.labels_changed.emit(data.labels)
+            if len(self._boundary_items) > 0:
+                b_items = self._boundary_items.pop(0)
+                self._plotitem.removeItem(b_items[0])
+                self._plotitem.removeItem(b_items[1])
+                self._plotitem.removeItem(self._fill_items.pop(0))
+
+        if data is not None:
+            for ind in range(len(data)):
+                self._plot_items.append(pg.PlotDataItem(pen=self._plot_colors[ind]))
+                self._plotitem.addItem(self._plot_items[-1])
+                self.legend.addItem(self._plot_items[-1], data.labels[ind])
+                if show_errors:
+                    self._boundary_items.append((pg.PlotDataItem(pen=list(self._plot_colors[ind]) + [100]),
+                                                 pg.PlotDataItem(pen=list(self._plot_colors[ind]) + [100])))
+                    self._plotitem.addItem(self._boundary_items[-1][0])
+                    self._plotitem.addItem(self._boundary_items[-1][1])
+                    self._fill_items.append(pg.FillBetweenItem(*self._boundary_items[-1],
+                                                               list(self._plot_colors[ind]) + [100]))
+                    self._plotitem.addItem(self._fill_items[-1])
+
+            self.updated_item.emit(self._plot_items)
+            self.labels_changed.emit(data.labels)
 
     @property
     def labels(self):
-        return self._data.labels
+        if self._data is None:
+            return []
+        else:
+            return self._data.labels
 
     def legend_items(self):
         return [item[1].text for item in self.legend.items]
@@ -190,27 +238,34 @@ class DataDisplayer(QObject):
                 self._plotitem.removeItem(self._overlay_items.pop(0))
         else:
             for ind in range(len(self._data)):
-                pen = pg.mkPen(color=PLOT_COLORS[ind], style=Qt.CustomDashLine)
+                pen = pg.mkPen(color=self._plot_colors[ind], style=Qt.CustomDashLine)
                 pen.setDashPattern([10, 10])
                 self._overlay_items.append(pg.PlotDataItem(pen=pen))
                 self._plotitem.addItem(self._overlay_items[-1])
                 if self._do_sort:
-                    self._overlay_items[ind].setData(self._axis.get_data(),
-                                                     self._data.sort_data()[ind])
+                    self._overlay_items[ind].setData(
+                        self._data.sort_data().get_axis_from_index(0)[0].get_data(),
+                        self._data.sort_data()[ind])
                 else:
-                    self._overlay_items[ind].setData(self._axis.get_data(), self._data[ind])
+                    self._overlay_items[ind].setData(
+                        self._data.get_axis_from_index(0)[0].get_data(),
+                        self._data[ind])
 
 
 
 class View1D(ActionManager, QObject):
-    def __init__(self, parent_widget: QtWidgets.QWidget = None):
+    def __init__(self, parent_widget: QtWidgets.QWidget = None, show_toolbar=True,
+                 no_margins=False, flip_axes=False):
         QObject.__init__(self)
         ActionManager.__init__(self, toolbar=QtWidgets.QToolBar())
 
+        self.no_margins = no_margins
+        self.flip_axes = flip_axes
+
         self.data_displayer: DataDisplayer = None
         self.plot_widget: PlotWidget = None
-        self.lineout_widgets: PlotWidget = None
-        self.graphical_widgets: dict = None
+        self.lineout_widgets: QtWidgets.QWidget = None
+        self.lineout_viewers: Viewer0D = None
         self.crosshair: Crosshair = None
 
         self.roi_target = pg.InfiniteLine(pen='w')
@@ -225,11 +280,10 @@ class View1D(ActionManager, QObject):
 
         self.plot_widget = PlotWidget()
         self.roi_manager = ROIManager('1D')
-        self.data_displayer = DataDisplayer(self.plotitem)
-
+        self.data_displayer = DataDisplayer(self.plotitem, flip_axes=self.flip_axes)
+        self.other_data_displayers: Dict[str, DataDisplayer] = {}
         self.setup_widgets()
 
-        self.lineout_plotter = LineoutPlotter(self.graphical_widgets, self.roi_manager, self.crosshair)
         self.connect_things()
         self.prepare_ui()
 
@@ -238,6 +292,29 @@ class View1D(ActionManager, QObject):
         self.roi_target.setVisible(False)
         self.ROIselect.setVisible(False)
 
+        self.show_toolbar = show_toolbar
+        if not self.show_toolbar:
+            self.splitter_ver.setSizes([0, 1, 0])
+
+    def add_data_displayer(self, displayer_name: str, plot_colors=PLOT_COLORS):
+        self.other_data_displayers[displayer_name] = DataDisplayer(self.plotitem, self.flip_axes,
+                                                                   plot_colors)
+
+    def remove_data_displayer(self, displayer_name: str):
+        displayer = self.other_data_displayers.pop(displayer_name, None)
+        if displayer is not None:
+            displayer.update_display_items()
+
+    @Slot(int, str, str)
+    def add_roi_displayer(self, index, roi_type='', roi_name=''):
+        color = self.roi_manager.ROIs[roi_name].color
+        self.lineout_viewers.view.add_data_displayer(
+            roi_name, make_dashed_pens(color, self.data_displayer.Ndata))
+
+    @Slot(str)
+    def remove_roi_displayer(self, roi_name=''):
+        self.lineout_viewers.view.remove_data_displayer(roi_name)
+
     def move_roi_target(self, pos: Iterable[float], **kwargs):
         if not self.roi_target.isVisible():
             self.roi_target.setVisible(True)
@@ -246,8 +323,10 @@ class View1D(ActionManager, QObject):
     def get_double_clicked(self):
         return self.plot_widget.view.sig_double_clicked
 
-    def display_roi_lineouts(self, roi_dict):
-        self.lineout_plotter.plot_roi_lineouts(roi_dict)
+    def display_roi_lineouts(self, roi_dte: DataToExport):
+        for roi_name in roi_dte.get_origins('Data0D'):
+            self.lineout_viewers.view.display_data(
+                roi_dte.get_data_from_name_origin('IntData', roi_name), displayer=roi_name)
 
     @property
     def axis(self):
@@ -270,13 +349,29 @@ class View1D(ActionManager, QObject):
         """Convenience function from the Crosshair"""
         self.crosshair.set_crosshair_position(*positions)
 
-    def display_data(self, data: DataWithAxes):
-        self.set_action_visible('xyplot', len(data) == 2)
-        self.data_displayer.update_data(data, self.is_action_checked('xyplot'), self.is_action_checked('sort'))
+    def display_data(self, data: Union[DataWithAxes, DataToExport], displayer: str = None):
+        if displayer is None:
+            if isinstance(data, DataWithAxes):
+                self.set_action_visible('xyplot', len(data) == 2)
+                self.data_displayer.update_data(data, self.is_action_checked('xyplot'),
+                                                self.is_action_checked('sort'),
+                                                do_scatter=self.is_action_checked('scatter'),
+                                                show_errors=self.is_action_checked('errors'))
+            elif isinstance(data, DataToExport):
+                self.set_action_visible('xyplot', len(data[0]) == 2)
+                self.data_displayer.update_data(data.pop(0), self.is_action_checked('xyplot'),
+                                                self.is_action_checked('sort'),
+                                                do_scatter=self.is_action_checked('scatter'),
+                                                show_errors=self.is_action_checked('errors'))
+                if len(data) > 0:
+                    self.data_displayer.add_other_data(data)
+        elif displayer in self.other_data_displayers:
+            self.other_data_displayers[displayer].update_data(data,
+                                                              self.is_action_checked('xyplot'),
+                                                              self.is_action_checked('sort'))
 
     def prepare_ui(self):
         self.show_hide_crosshair(False)
-        self.show_lineout_widgets()
 
     def do_math(self):
         try:
@@ -293,27 +388,30 @@ class View1D(ActionManager, QObject):
     @Slot(int, str)
     def update_roi_channels(self, index, roi_type=''):
         """Update the use_channel setting each time a ROI is added"""
-        item_param = self.roi_manager.settings.child('ROIs', self.roi_manager.roi_format(index))
-        item_param.child('use_channel').setOpts(limits=self.data_displayer.labels)
-        item_param.child('use_channel').setValue(self.data_displayer.labels[0])
+        self.roi_manager.update_use_channel(self.data_displayer.labels.copy())
 
     def setup_widgets(self):
         self.parent_widget.setLayout(QtWidgets.QVBoxLayout())
+        if self.no_margins:
+            self.parent_widget.layout().setContentsMargins(0, 0, 0, 0)
         splitter_hor = QtWidgets.QSplitter(Qt.Horizontal)
         self.parent_widget.layout().addWidget(splitter_hor)
 
-        splitter_ver = QtWidgets.QSplitter(Qt.Vertical)
-        splitter_hor.addWidget(splitter_ver)
+        self.splitter_ver = QtWidgets.QSplitter(Qt.Vertical)
+        splitter_hor.addWidget(self.splitter_ver)
         splitter_hor.addWidget(self.roi_manager.roiwidget)
         self.roi_manager.roiwidget.hide()
 
-        splitter_ver.addWidget(self.toolbar)
+        self.splitter_ver.addWidget(self.toolbar)
 
-        self.lineout_widgets = PlotWidget()
-        self.graphical_widgets = dict(lineouts=dict(int=self.lineout_widgets))
+        self.lineout_widgets = QtWidgets.QWidget()
+        self.lineout_viewers = Viewer0D(self.lineout_widgets, show_toolbar=False,
+                                        no_margins=True)
+        self.lineout_widgets.setContentsMargins(0, 0, 0, 0)
+        self.lineout_widgets.hide()
 
-        splitter_ver.addWidget(self.plot_widget)
-        splitter_ver.addWidget(self.lineout_widgets)
+        self.splitter_ver.addWidget(self.plot_widget)
+        self.splitter_ver.addWidget(self.lineout_widgets)
         self.roi_manager.viewer_widget = self.plot_widget
 
         self.crosshair = Crosshair(self.plotitem, orientation='vertical')
@@ -323,41 +421,47 @@ class View1D(ActionManager, QObject):
         self.connect_action('aspect_ratio', self.lock_aspect_ratio)
 
         self.connect_action('do_math', self.do_math)
-        self.connect_action('do_math', self.lineout_plotter.roi_clicked)
-
-        self.connect_action('scatter', self.data_displayer.plot_with_scatter)
+        self.connect_action('scatter', self.data_displayer.update_scatter)
         self.connect_action('xyplot', self.data_displayer.update_xy)
         self.connect_action('sort', self.data_displayer.update_sort)
         self.connect_action('crosshair', self.show_hide_crosshair)
-        self.connect_action('crosshair', self.lineout_plotter.crosshair_clicked)
         self.connect_action('overlay', self.data_displayer.show_overlay)
+        self.connect_action('errors', self.data_displayer.update_errors)
         self.connect_action('ROIselect', self.show_ROI_select)
 
         self.roi_manager.new_ROI_signal.connect(self.update_roi_channels)
+        self.roi_manager.new_ROI_signal.connect(self.add_roi_displayer)
+        self.roi_manager.new_ROI_signal.connect(self.lineout_viewers.get_action('clear').click)
+        self.roi_manager.remove_ROI_signal.connect(self.remove_roi_displayer)
+
+        self.roi_manager.color_signal.connect(self.update_colors)
         self.data_displayer.labels_changed.connect(self.roi_manager.update_use_channel)
 
+    def update_colors(self, colors: list):
+        for ind, roi_name in enumerate(self.roi_manager.ROIs):
+            self.lineout_viewers.update_colors(make_dashed_pens(colors[ind]), displayer=roi_name)
+
     def show_ROI_select(self):
         self.ROIselect.setVisible(self.is_action_checked('ROIselect'))
 
-    def show_lineout_widgets(self):
-        state = self.is_action_checked('do_math') or self.is_action_checked('crosshair')
-        for lineout_name in LineoutPlotter.lineout_widgets:
-            lineout = self.lineout_plotter.get_lineout_widget(lineout_name)
-            lineout.setMouseEnabled(state, state)
-            lineout.showAxis('left', state)
-            lineout.setVisible(state)
-            lineout.update()
-
     def setup_actions(self):
         self.add_action('do_math', 'Math', 'Calculator', 'Do Math using ROI', checkable=True)
         self.add_action('crosshair', 'Crosshair', 'reset', 'Show data cursor', checkable=True)
-        self.add_action('aspect_ratio', 'AspectRatio', 'Zoom_1_1', 'Fix the aspect ratio', checkable=True)
-        self.add_action('scatter', 'Scatter', 'Marker', 'Switch between line or scatter plots', checkable=True)
+        self.add_action('aspect_ratio', 'AspectRatio', 'Zoom_1_1', 'Fix the aspect ratio',
+                        checkable=True)
+        self.add_action('scatter', 'Scatter', 'Marker', 'Switch between line or scatter plots',
+                        checkable=True)
         self.add_action('xyplot', 'XYPlotting', '2d',
-                        'Switch between normal or XY representation (valid for 2 channels)', checkable=True,
+                        'Switch between normal or XY representation (valid for 2 channels)',
+                        checkable=True,
                         visible=False)
-        self.add_action('overlay', 'Overlay', 'overlay', 'Plot overlays of current data', checkable=True)
-        self.add_action('sort', 'Sort Data', 'sort_ascend', 'Display data in a sorted fashion with respect to axis',
+        self.add_action('overlay', 'Overlay', 'overlay', 'Plot overlays of current data',
+                        checkable=True)
+        self.add_action('errors', 'Errors', 'Statistics2', 'Plot boundaries (~error bars) of '
+                                                           'the data',
+                        checkable=True)
+        self.add_action('sort', 'Sort Data', 'sort_ascend',
+                        'Display data in a sorted fashion with respect to axis',
                         checkable=True)
         self.add_action('ROIselect', 'ROI Select', 'Select_24',
                         tip='Show/Hide ROI selection area', checkable=True)
@@ -370,16 +474,14 @@ class View1D(ActionManager, QObject):
         else:
             self.plotitem.vb.setAspectLocked(lock=False)
 
-    def update_crosshair_data(self, crosshair_dict: dict):
-        try:
+    def update_crosshair_data(self, crosshair_dte: DataToExport):
+        if len(crosshair_dte) > 0:
+            dwa = crosshair_dte[0]
             string = "y="
-            for key in crosshair_dict:
-                string += "{:.3e} / ".format(crosshair_dict[key]['value'])
+            for data_array in dwa:
+                string += f"{float(data_array[0]):.3e} / "
             self.get_action('y_label').setText(string)
-            self.get_action('x_label').setText(f"x={crosshair_dict[key]['pos']:.3e} ")
-
-        except Exception as e:
-            pass
+            self.get_action('x_label').setText(f"x={float(dwa.axes[0].get_data()[0]):.3e} ")
 
     @Slot(bool)
     def show_hide_crosshair(self, show=True):
@@ -395,16 +497,24 @@ class View1D(ActionManager, QObject):
 
 
 class Viewer1D(ViewerBase):
-    """this plots 1D data on a plotwidget. Math and measurement can be done on it.
+    """ DataWithAxis of type Data1D can be plotted using this data viewer
+
+    Methods
+    -------
+    show_data:
+        parameter:
+        * dwa: a DataWithaxis
+        * scatter_dwa: an optional extra DataWithAxis to be plotted with scatter points
+          it could define extra_attributes such as symbol: str (to define the symbol layout
+          default: 'o') and symbol_size: int (to define the symbol size)
 
-    Datas and measurements are then exported with the signal data_to_export_signal
     """
-    ROI_select_signal = Signal(QRectF)
 
-    def __init__(self, parent: QtWidgets.QWidget = None, title=''):
+    def __init__(self, parent: QtWidgets.QWidget = None, title='', show_toolbar=True, no_margins=False,
+                 flip_axes=False):
         super().__init__(parent=parent, title=title)
 
-        self.view = View1D(self.parent)
+        self.view = View1D(self.parent, show_toolbar=show_toolbar, no_margins=no_margins, flip_axes=flip_axes)
 
         self.filter_from_rois = Filter1DFromRois(self.view.roi_manager)
         self.filter_from_rois.register_activation_signal(self.view.get_action('do_math').triggered)
@@ -418,6 +528,12 @@ class Viewer1D(ViewerBase):
 
         self._labels = []
 
+    def update_colors(self, colors: List, displayer=None):
+        if displayer is None:
+            self.view.data_displayer.update_colors(colors)
+        elif displayer in self.view.other_data_displayers:
+            self.view.other_data_displayers[displayer].update_colors(colors)
+
     @property
     def roi_manager(self):
         """Convenience method """
@@ -443,57 +559,47 @@ class Viewer1D(ViewerBase):
     def add_plot_item(self, item):
         self.view.add_plot_item(item)
 
-    @Slot(dict)
-    def process_crosshair_lineouts(self, crosshair_dict):
-        self.view.update_crosshair_data(crosshair_dict)
+    def process_crosshair_lineouts(self, crosshair_dte: DataToExport):
+        self.view.update_crosshair_data(crosshair_dte)
         self.crosshair_dragged.emit(*self.view.crosshair.get_positions())
 
-    @Slot(dict)
-    def process_roi_lineouts(self, roi_dict):
-        self.view.display_roi_lineouts(roi_dict)
+    def process_roi_lineouts(self, roi_dte: DataToExport):
+        self.view.display_roi_lineouts(roi_dte)
         self.measure_data_dict = dict([])
-        for roi_key, lineout_data in roi_dict.items():
-            if not self._display_temporary:
-                if lineout_data.hor_data.size != 0:
-                    self.data_to_export.append(
-                        DataFromRoi(name=f'Hlineout_{roi_key}', data=[lineout_data.hor_data],
-                                    axes=[Axis(data=lineout_data.hor_axis.get_data(),
-                                               units=lineout_data.hor_axis.units,
-                                               label=lineout_data.hor_axis.label,
-                                               index=0)]))
-
-                    self.data_to_export.append(DataCalculated(name=f'Integrated_{roi_key}',
-                                                              data=[lineout_data.math_data]))
-
-            self.measure_data_dict[f'{roi_key}:'] = lineout_data.math_data
-
-            QtWidgets.QApplication.processEvents()
-
+        self.measure_data_dict = roi_dte.merge_as_dwa('Data0D').to_dict()
+        QtWidgets.QApplication.processEvents()
         self.view.roi_manager.settings.child('measurements').setValue(self.measure_data_dict)
+
         if not self._display_temporary:
+            roi_dte_bis = roi_dte.deepcopy()
+            for dwa in roi_dte_bis:
+                if dwa.name == 'HorData':
+                    dwa.name = f'Hlineout_{dwa.origin}'
+                elif dwa.name == 'IntData':
+                    dwa.name = f'Integrated_{dwa.origin}'
+            self.data_to_export.append(roi_dte_bis.data)
             self.data_to_export_signal.emit(self.data_to_export)
         self.ROI_changed.emit()
 
     def prepare_connect_ui(self):
         self.view.ROIselect.sigRegionChangeFinished.connect(self.selected_region_changed)
         self._data_to_show_signal.connect(self.view.display_data)
-        self.view.lineout_plotter.roi_changed.connect(self.roi_changed)
+        self.roi_manager.roi_changed.connect(self.roi_changed)
+        self.roi_manager.roi_value_changed.connect(self.roi_changed)
+
         self.view.get_crosshair_signal().connect(self.crosshair_changed)
         self.view.get_double_clicked().connect(self.double_clicked)
 
     def selected_region_changed(self):
         if self.view.is_action_checked('ROIselect'):
-            pos = self.view.ROIselect.getRegion()
-            self.ROI_select_signal.emit(QRectF(pos[0], pos[1], 0, 0))
+            self.roi_select_signal.emit(RoiInfo.info_from_linear_roi(self.view.ROIselect))
 
-    @Slot(float, float)
     def double_clicked(self, posx, posy=0):
         if self.view.is_action_checked('crosshair'):
             self.view.crosshair.set_crosshair_position(posx)
             self.crosshair_changed()
         self.sig_double_clicked.emit(posx, posy)
 
-    @Slot(dict)
     def roi_changed(self):
         self.filter_from_rois.filter_data(self._raw_data)
 
@@ -513,12 +619,21 @@ class Viewer1D(ViewerBase):
         if labels != self._labels:
             self._labels = labels
 
-    def _show_data(self, data: DataWithAxes):
+    def _show_data(self, data: DataWithAxes, *args, scatter_dwa: DataWithAxes =None,
+                   **kwargs):
         self.labels = data.labels
+        if len(data.axes) == 0:
+            self.get_axis_from_view(data)
 
-        self.get_axis_from_view(data)
         self.view.display_data(data)
 
+        if scatter_dwa is not None:
+            if isinstance(scatter_dwa, DataWithAxes):
+                if scatter_dwa.name not in self.view.other_data_displayers:
+                    self.view.add_data_displayer(scatter_dwa.name, [(255, 0, 0)])
+                self.view.other_data_displayers[scatter_dwa.name].update_data(
+                    scatter_dwa, do_scatter=True)
+
         if len(self.view.roi_manager.ROIs) == 0:
             self.data_to_export_signal.emit(self.data_to_export)
         else:
@@ -527,9 +642,10 @@ class Viewer1D(ViewerBase):
             self.crosshair_changed()
 
     def get_axis_from_view(self, data: DataWithAxes):
-        if len(data.axes) == 0:
-            if self.view.axis is not None:
-                data.axes = [self.view.axis]
+        if self.view.axis is not None:
+            data.axes = [self.view.axis]
+        else:
+            data.create_missing_axes()
 
     def update_status(self, txt):
         logger.info(txt)
@@ -556,7 +672,7 @@ def main():
 
     # x = np.sin(np.linspace(0,6*np.pi,201))
     # y = np.sin(np.linspace(0, 6*np.pi, 201)+np.pi/2)
-    data = DataRaw('mydata', data=[y1, ydata_expodec],
+    data = DataRaw('mydata', data=[y1, ydata_expodec, -ydata_expodec, -y1],
                    axes=[Axis('myaxis', 'units', data=x)])
 
     Form.show()
@@ -617,6 +733,55 @@ def main_random():
     QtWidgets.QApplication.processEvents()
     sys.exit(app.exec_())
 
+def main_extra_scatter():
+    app = QtWidgets.QApplication(sys.argv)
+    widget = QtWidgets.QWidget()
+    prog = Viewer1D(widget)
+
+    from pymodaq.utils.math_utils import gauss1D
+    x = np.linspace(0, 200, 201)
+    xlow = np.linspace(0, 200, 21)
+    y = gauss1D(x, 75, 25)
+    ylow = gauss1D(xlow, 75, 25)
+
+    QtWidgets.QApplication.processEvents()
+    data = DataRaw('mydata', data=[y],
+                   axes=[Axis('myaxis', 'units', data=x, index=0, spread_order=0)],
+                   labels=['Initial data'],
+                   )
+    scatter_dwa = DataRaw('scatter', data=[ylow],
+                          axes=[Axis('myaxis', 'units', data=xlow, index=0, spread_order=0)],
+                          labels=['subsampled'],
+                          symbol='d',
+                          symbol_size=18,
+                          color='b')
+
+    widget.show()
+    prog.show_data(data, scatter_dwa=scatter_dwa)
+    QtWidgets.QApplication.processEvents()
+    sys.exit(app.exec_())
+
+def main_errors():
+    app = QtWidgets.QApplication(sys.argv)
+    widget = QtWidgets.QWidget()
+    prog = Viewer1D(widget)
+
+    from pymodaq.utils.math_utils import gauss1D
+    x = np.linspace(0, 200, 201)
+    y1 = gauss1D(x, 75, 25)
+    y2 = gauss1D(x, 120, 50, 2)
+
+    QtWidgets.QApplication.processEvents()
+    data = DataRaw('mydata', data=[y1, y2],
+                   axes=[Axis('myaxis', 'units', data=x, index=0, spread_order=0)],
+                   errors=(np.random.random_sample(x.shape),
+                           np.random.random_sample(x.shape)))
+
+
+    widget.show()
+    prog.show_data(data)
+    QtWidgets.QApplication.processEvents()
+    sys.exit(app.exec_())
 
 def main_view1D():
     app = QtWidgets.QApplication(sys.argv)
@@ -648,6 +813,8 @@ def main_nans():
 
 if __name__ == '__main__':  # pragma: no cover
     # main()
-    main_random()
+    # main_random()
+    #main_errors()
+    main_extra_scatter()
     #main_view1D()
     #main_nans()