vidavis 0.1.3__tar.gz → 0.1.5__tar.gz

{vidavis-0.1.3 → vidavis-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vidavis
-Version: 0.1.3
+Version: 0.1.5
 Summary: Radio astronomy visibility data visualization
 License: LGPL
 Author-email: Darrell Schiebel <darrell@schiebel.us>,Pam Harris <pharris@nrao.edu>

{vidavis-0.1.3 → vidavis-0.1.5}/pyproject.toml

@@ -16,7 +16,7 @@ dependencies = [
 ]
 requires-python = ">=3.11, <3.14"
 readme = "readme.rst"
-version = "0.1.3"
+version = "0.1.5"
 
 [project.license]
 text = "LGPL"

{vidavis-0.1.3 → vidavis-0.1.5}/src/vidavis/apps/_ms_raster.py

@@ -521,15 +521,16 @@ class MsRaster(MsPlot):
         # Add plot inputs to GUI, change plot button to outline, and stop spinner
         self._update_plot_status(False)
         self._update_plot_spinner(False)
-
 # pylint: enable=too-many-arguments, too-many-positional-arguments
 
-    def _locate_gui_points(self, x, y, data, bounds):
+    def _locate_gui_points(self, x, y, data, boxes):
         ''' Callback for locate streams '''
         if self._gui_plot_data:
+            if super()._locate_points(data, self._gui_plot_data, self._gui_panel[2]):
+                return self._last_gui_plot
+            if super()._locate_boxes(boxes, self._gui_plot_data, self._gui_panel[3]):
+                return self._last_gui_plot
             super()._locate_cursor(x, y, self._gui_plot_data, self._gui_panel[0][1])
-            super()._locate_points(data, self._gui_plot_data, self._gui_panel[2])
-            super()._locate_box(bounds, self._gui_plot_data, self._gui_panel[3])
         return self._last_gui_plot
 
     def _do_gui_selection(self):
@@ -578,17 +579,18 @@ class MsRaster(MsPlot):
         return self._empty_plot
 
     def _create_empty_plot(self):
-        ''' Create empty Overlay plot for DynamicMap with colormap params and required tools enabled '''
+        ''' Create empty Overlay plot for DynamicMap with colormap params enabled '''
         plot_params = self._raster_plot.get_plot_params()
         self._empty_plot = hv.Overlay(
             hv.QuadMesh([]).opts(
-                colorbar=plot_params['style']['show_flagged_colorbar'],
-                cmap=plot_params['style']['flagged_cmap'],
-                responsive=True,
-            ) * hv.QuadMesh([]).opts(
                 colorbar=plot_params['style']['show_colorbar'],
-                colorbar_position='left',
                 cmap=plot_params['style']['unflagged_cmap'],
+                colorbar_position='left',
+                responsive=True,
+            ) * hv.QuadMesh([]).opts(
+                colorbar=plot_params['style']['show_flagged_colorbar'],
+                colorbar_position='right',
+                cmap=plot_params['style']['flagged_cmap'],
                 responsive=True,
             )
         )

{vidavis-0.1.3 → vidavis-0.1.5}/src/vidavis/data/measurement_set/processing_set/_ps_raster_data.py

@@ -30,7 +30,7 @@ def raster_data(ps_xdt, plot_inputs, logger):
         raise RuntimeError("Plot failed: raster plane selection yielded data with all nan values.")
 
     # Compute complex component of vis data
-    raster_xds[correlated_data] = get_axis_data(raster_xds, plot_inputs['vis_axis'], data_group).compute()
+    raster_xds[correlated_data] = get_axis_data(raster_xds, plot_inputs['vis_axis'], data_group)
 
     # Convert float time to datetime
     set_datetime_coordinate(raster_xds)

{vidavis-0.1.3 → vidavis-0.1.5}/src/vidavis/plot/ms_plot/_locate_points.py

@@ -10,32 +10,41 @@ import panel as pn
 
 from vidavis.plot.ms_plot._ms_plot_constants import TIME_FORMAT
 
-def cursor_changed(cursor, last_cursor):
-    ''' Check whether cursor position changed '''
-    x, y = cursor
-    if not x and not y:
-        return False # not cursor callback
-    if last_cursor and last_cursor == (x, y):
-        return False # same cursor
-    return True # new cursor or cursor changed
-
-def points_changed(data, last_points):
-    ''' Check whether point positions changed '''
-    # No data = {'x': [], 'y': []}
-    if not data or (len(data['x']) == 0 and len(data['y']) == 0):
-        return False # not points callback
-    if last_points and last_points == data:
-        return False # same points
-    return True # new points, points changed, or points deleted
-
-def box_changed(bounds, last_box):
-    ''' Check whether box position changed '''
-    # No bounds = None
-    if not bounds:
-        return False # no data, not box select callback
-    if last_box and last_box == bounds:
-        return False # same box
-    return True # new box, box changed, or box deleted
+def get_locate_value(xds, coord, value):
+    ''' Convert index coordinates to int and float time coordinate to datetime. Select nearest value <= value. '''
+    if coord in ['baseline', 'antenna_name', 'polarization']:
+        # Convert float to int index value
+        return round(value)
+
+    if coord in ['time', 'frequency']:
+        if coord=='time' and isinstance(value, float):
+            # Convert float to datetime value
+            # Bokeh datetime values are floating point values that represent milliseconds-since-epoch (unix time)
+            value = to_datetime(value, unit='ms')
+        value_sel = {coord: value}
+        nearest_value = xds[coord].sel(indexers=None, method='nearest', tolerance=None, drop=False, **value_sel).values
+        return nearest_value
+
+    return value
+
+def data_changed(data, last_data):
+    ''' Check whether data changed, input as list of tuples '''
+    if not data:
+        return False # not callback for this data
+    if last_data and len(last_data) == len(data) and last_data == data:
+        return False # same data
+    return True # new data, data changed, or data removed
+
+def get_new_data(data, last_data):
+    ''' Return data not in last_data, input as list of tuples '''
+    new_data = []
+    if last_data:
+        for info in data:
+            if info not in last_data:
+                new_data.append(info)
+    else:
+        new_data = data
+    return new_data
 
 def update_cursor_location(cursor, plot_axes, xds, cursor_locate_box):
     ''' Show data values for cursor x,y position in cursor location box (pn.WidgetBox) '''
@@ -47,42 +56,40 @@ def update_cursor_location(cursor, plot_axes, xds, cursor_locate_box):
     cursor_position = {x_axis: x, y_axis: y}
     cursor_location = _locate_point(xds, cursor_position, vis_axis)
 
-    location_column = pn.Column(pn.widgets.StaticText(name="CURSOR LOCATION"))
     # Add row of columns to column layout
+    location_column = pn.Column(pn.widgets.StaticText(name="CURSOR LOCATION"))
     location_row = _layout_point_location(cursor_location)
     location_column.append(location_row)
+
     # Add location column to widget box
     cursor_locate_box.append(location_column)
 
-def update_points_location(data, plot_axes, xds, points_tab_feed):
+def update_points_location(points, plot_axes, xds, points_tab_feed):
     ''' Show data values for points in point_draw in tab and log '''
-    points_tab_feed.clear()
     locate_log = []
-    if data:
-        x_axis, y_axis, vis_axis = plot_axes
-        message = f"Locate {len(data['x'])} points:"
-        locate_log.append(message)
-        for point in list(zip(data['x'], data['y'])):
-            # Locate point
-            point_position = {x_axis: point[0], y_axis: point[1]}
-            point_location = _locate_point(xds, point_position, vis_axis)
-            # Format location and add to points locate column
-            location_layout = _layout_point_location(point_location)
-            points_tab_feed.append(location_layout)
-            points_tab_feed.append(pn.layout.Divider())
-
-            # Format and add to log
-            location_list = [f"{static_text.name}={static_text.value}" for static_text in point_location]
-            locate_log.append(", ".join(location_list))
+    x_axis, y_axis, vis_axis = plot_axes
+    for point in points:
+        # Locate point
+        point_position = {x_axis: point[0], y_axis: point[1]}
+        point_location = _locate_point(xds, point_position, vis_axis)
+
+        # Format location and add to points locate column
+        location_layout = _layout_point_location(point_location)
+        points_tab_feed.append(location_layout)
+        points_tab_feed.append(pn.layout.Divider())
+
+        # Format and add to log
+        location_list = [f"{static_text.name}={static_text.value}" for static_text in point_location]
+        locate_log.append(", ".join(location_list))
     return locate_log
 
-def update_box_location(bounds, plot_axes, xds, box_tab_feed):
+# pylint: disable=too-many-locals
+def update_boxes_location(boxes, plot_axes, xds, box_tab_feed):
     ''' Show data values for points in box_select in tab and log '''
-    box_tab_feed.clear()
     locate_log = []
-    if bounds:
-        x_axis, y_axis, vis_axis = plot_axes
-        box_bounds = {x_axis: (bounds[0], bounds[2]), y_axis: (bounds[1], bounds[3])}
+    x_axis, y_axis, vis_axis = plot_axes
+    for box in boxes:
+        box_bounds = {x_axis: (box[0], box[2]), y_axis: (box[1], box[3])}
         npoints, point_locations = _locate_box(xds, box_bounds, vis_axis)
 
         message = f"Locate {npoints} points"
@@ -100,6 +107,7 @@ def update_box_location(bounds, plot_axes, xds, box_tab_feed):
             location_list = [f"{static_text.name}={static_text.value}" for static_text in point]
             locate_log.append(", ".join(location_list))
     return locate_log
+# pylint: enable=too-many-locals
 
 def _locate_point(xds, position, vis_axis):
     '''
@@ -141,8 +149,9 @@ def _locate_box(xds, bounds, vis_axis):
             selection = {}
             for coord, val in bounds.items():
                 # Round index values to int for selection
-                selection[coord] = slice(_get_selection_value(coord, val[0]), _get_selection_value(coord, val[1]))
+                selection[coord] = slice(get_locate_value(xds, coord, val[0]), get_locate_value(xds, coord, val[1]))
             sel_xds = xds.sel(indexers=None, method=None, tolerance=None, drop=False, **selection)
+            sel_xds.compute()
 
             x_coord, y_coord = bounds.keys()
             npoints = sel_xds.sizes[x_coord] * sel_xds.sizes[y_coord]
@@ -175,10 +184,6 @@ def _get_point_location(xds, position, vis_axis):
 
     if xds:
         try:
-            for coord, value in position.items():
-                # Round index coordinates to int and convert time to datetime if float for selection
-                position[coord] = _get_selection_value(coord, value)
-
             sel_xds = xds.sel(indexers=None, method='nearest', tolerance=None, drop=False, **position)
             for coord in sel_xds.coords:
                 if coord == 'uvw_label' or ('baseline_antenna' in coord and 'baseline_name' in sel_xds.coords):
@@ -206,16 +211,6 @@ def _get_point_location(xds, position, vis_axis):
         values[vis_axis.upper()] = values.pop('VISIBILITY')
     return values, units
 
-def _get_selection_value(coord, value):
-    ''' Convert index coordinates to int and float time coordinate to datetime '''
-    if coord in ['baseline', 'antenna_name', 'polarization']:
-        # Round index coordinates to int for selecction
-        value = round(value)
-    elif coord == 'time' and isinstance(value, float):
-        # Bokeh datetime values are floating-point numbers: milliseconds since the Unix epoch
-        value = to_datetime(value, unit='ms', origin='unix')
-    return value
-
 def _get_xda_val_unit(xda):
     ''' Return value and unit of xda (selected so only one value) '''
     # Value

{vidavis-0.1.3 → vidavis-0.1.5}/src/vidavis/plot/ms_plot/_ms_plot.py

@@ -17,7 +17,7 @@ from selenium import webdriver
 from toolviper.utils.logger import setup_logger
 
 from vidavis.data.measurement_set._ms_data import MsData
-from vidavis.plot.ms_plot._locate_points import cursor_changed, points_changed, box_changed, update_cursor_location, update_points_location, update_box_location
+from vidavis.plot.ms_plot._locate_points import get_locate_value, data_changed, get_new_data, update_cursor_location, update_points_location, update_boxes_location
 from vidavis.toolbox import AppContext
 
 class MsPlot:
@@ -73,9 +73,9 @@ class MsPlot:
         self._plot_axes = None
         self._last_cursor = None
         self._last_points = None
-        self._last_box = None
+        self._last_boxes = None
         self._locate_plot_options = {
-            'tools': ['box_select', 'hover'],
+            'muted_alpha': 0,
             'selection_fill_alpha': 0.2,    # dim selected areas of plot
             'nonselection_fill_alpha': 1.0, # do not dim unselected areas of plot
         }
@@ -189,10 +189,11 @@ class MsPlot:
             if inputs_column:
                 self._show_panel.append(('Plot Inputs', inputs_column))
         else:
-            plot = plot.opts(
+            plot = plot.options(
                 hv.opts.QuadMesh(**self._locate_plot_options),
-                hv.opts.Scatter(**self._locate_plot_options)
+                hv.opts.Scatter(**self._locate_plot_options),
             )
+
             # Add DynamicMap for streams for single plot
             dmap = self._get_locate_dmap(self._locate)
 
@@ -210,8 +211,11 @@ class MsPlot:
             # Add tabs for inputs and locate
             if inputs_column:
                 self._show_panel.append(('Plot Inputs', inputs_column))
-            self._show_panel.append(('Locate Selected Points', pn.Feed(height_policy='max')))
-            self._show_panel.append(('Locate Selected Box', pn.Feed(height_policy='max')))
+            self._show_panel.append(('Locate Points', pn.Feed(height_policy='max')))
+            self._show_panel.append(('Locate Box', pn.Feed(height_policy='max')))
+
+            # Compute coordinate values for locate
+            self._compute_plot_metadata(self._plot_data)
 
             # return value for locate callback
             self._last_plot = plot
@@ -397,21 +401,28 @@ class MsPlot:
                 str_pane.margin = (0, 10)
                 inputs_tab_column.append(str_pane)
 
+    def _compute_plot_metadata(self, xds):
+        ''' Compute coordinate dask arrays to numpy arrays in memory '''
+        for coord in xds.coords:
+            xds[coord] = xds[coord].compute()
+
     def _get_locate_dmap(self, callback):
         ''' Return DynamicMap with streams callback to locate points '''
         points = hv.Points([]).opts(
             size=5,
             fill_color='white'
         )
+        boxes = hv.Rectangles([])
         dmap = hv.DynamicMap(
             callback,
             streams=[
-                hv.streams.PointerXY(),              # cursor location (x, y)
-                hv.streams.PointDraw(source=points), # fixed points location (data)
-                hv.streams.BoundsXY()                # box location (bounds)
+                hv.streams.PointerXY(),                               # cursor location (x, y)
+                hv.streams.PointDraw(source=points),                  # fixed points location (data)
+                hv.streams.BoxEdit(source=boxes).rename(data='boxes') # box location (boxes)
             ]
         )
-        return dmap * points
+        return (dmap * points * boxes).options(
+            hv.opts.Rectangles(fill_alpha=0.5, line_color='white'))
 
     def _unlink_plot_locate(self):
         ''' Disconnect streams when plot data is going to be replaced '''
@@ -432,45 +443,97 @@ class MsPlot:
             self._plot_axes = (x_axis, y_axis, vis_axis)
         return self._plot_axes
 
-    def _locate(self, x, y, data, bounds):
+    def _locate(self, x, y, data, boxes):
         ''' Callback for all show plot streams '''
+        if self._locate_points(data, self._plot_data, self._show_panel[2]):
+            return self._last_plot
+
+        if self._locate_boxes(boxes, self._plot_data, self._show_panel[3]):
+            return self._last_plot
+
         self._locate_cursor(x, y, self._plot_data, self._show_panel[0][1])
-        self._locate_points(data, self._plot_data, self._show_panel[2])
-        self._locate_box(bounds, self._plot_data, self._show_panel[3])
         return self._last_plot
 
     def _locate_cursor(self, x, y, plot_data, cursor_box):
         ''' Show location from cursor position in cursor locate box '''
+        if not x and not y: # not cursor callback
+            return False
+        plot_axes = self._get_plot_axes()
+        x = get_locate_value(plot_data, plot_axes[0], x)
+        y = get_locate_value(plot_data, plot_axes[1], y)
         cursor = (x, y)
-        if cursor_changed(cursor, self._last_cursor):
-            # new cursor position - update cursor location box
-            update_cursor_location(cursor, self._get_plot_axes(), plot_data, cursor_box)
-            self._last_cursor = cursor
+
+        if not data_changed(cursor, self._last_cursor):
+            return False
+
+        # new cursor position - update cursor location box
+        update_cursor_location(cursor, plot_axes, plot_data, cursor_box)
+        self._last_cursor = cursor
+        return True
 
     def _locate_points(self, point_data, plot_data, points_tab):
         ''' Show points locations from point_draw tool '''
-        if points_changed(point_data, self._last_points):
-            # update selected points location tab
-            location_info = update_points_location(point_data, self._get_plot_axes(), plot_data, points_tab)
+        if not point_data or len(point_data['x']) == 0: # not points callback
+            return False
+
+        plot_axes = self._get_plot_axes()
+        x_vals = point_data['x']
+        y_vals = point_data['y']
+        point_data['x'] = [get_locate_value(plot_data, plot_axes[0], x) for x in x_vals]
+        point_data['y'] = [get_locate_value(plot_data, plot_axes[1], y) for y in y_vals]
+        data_points = list(zip(point_data['x'], point_data['y']))
+
+        if not data_changed(data_points, self._last_points):
+            return False
+
+        # update selected points location tab with new points
+        points_to_locate = get_new_data(data_points, self._last_points)
+        self._last_points = data_points
 
-            # log to file only
-            self._logger.removeHandler(self._stdout_handler)
-            for info in location_info:
-                self._logger.info(info)
-            self._logger.addHandler(self._stdout_handler)
+        if not points_to_locate: # point deleted
+            return False
 
-            self._last_points = point_data
+        if len(points_to_locate) == len(data_points):
+            points_tab.clear() # clear for locating all points
 
-    def _locate_box(self, box_bounds, plot_data, box_tab):
+        location_info = update_points_location(points_to_locate, self._get_plot_axes(), plot_data, points_tab)
+        self._log_to_file_only(location_info)
+        return True
+
+    def _locate_boxes(self, boxes, plot_data, box_tab):
         ''' Show points locations in box from box_select tool '''
-        if box_changed(box_bounds, self._last_box):
-            # update selected box location tab
-            location_info = update_box_location(box_bounds, self._get_plot_axes(), plot_data, box_tab)
+        if not boxes or len(boxes['x0']) == 0: # not box callback
+            return False
 
-            # log to file only
-            self._logger.removeHandler(self._stdout_handler)
-            for info in location_info:
-                self._logger.info(info)
-            self._logger.addHandler(self._stdout_handler)
+        plot_axes = self._get_plot_axes()
+        x0_vals = boxes['x0']
+        y0_vals = boxes['y0']
+        x1_vals = boxes['x1']
+        y1_vals = boxes['y1']
+        boxes['x0'] = [get_locate_value(plot_data, plot_axes[0], x0) for x0 in x0_vals]
+        boxes['y0'] = [get_locate_value(plot_data, plot_axes[1], y0) for y0 in y0_vals]
+        boxes['x1'] = [get_locate_value(plot_data, plot_axes[0], x1) for x1 in x1_vals]
+        boxes['y1'] = [get_locate_value(plot_data, plot_axes[1], y1) for y1 in y1_vals]
+        box_list = list(zip(boxes['x0'], boxes['y0'], boxes['x1'], boxes['y1']))
+
+        if not data_changed(box_list, self._last_boxes):
+            return False
 
-            self._last_box = box_bounds
+        # update selected box location tab with new boxes
+        boxes_to_locate = get_new_data(box_list, self._last_boxes)
+        self._last_boxes = box_list
+
+        if not boxes_to_locate: # box deleted
+            return False
+
+        box_tab.clear()
+        location_info = update_boxes_location(boxes_to_locate, self._get_plot_axes(), plot_data, box_tab)
+        self._log_to_file_only(location_info)
+        return True
+
+    def _log_to_file_only(self, messages):
+        ''' log messages to file only '''
+        self._logger.removeHandler(self._stdout_handler)
+        for message in messages:
+            self._logger.info(message)
+        self._logger.addHandler(self._stdout_handler)

{vidavis-0.1.3 → vidavis-0.1.5}/src/vidavis/plot/ms_plot/_ms_plot_selectors.py

@@ -80,7 +80,8 @@ def style_selector(style_callback, color_range_callback):
     )
 
     color_range_slider = pn.widgets.RangeSlider(
-        name="Colorbar range",
+        name="Set manual color range",
+        align=('start', 'end'), # (horizontal, vertical) to place left (h=start) and bottom (v=end)
     )
 
     select_color_range = pn.bind(color_range_callback, color_mode_selector, color_range_slider)

{vidavis-0.1.3 → vidavis-0.1.5}/src/vidavis/plot/ms_plot/_raster_plot.py

@@ -95,31 +95,31 @@ class RasterPlot:
             return None
 
         data_params = self._plot_params['data']
-        plot_params = self._plot_params['plot']
-
-        x_axis = plot_params['axis_labels']['x']['axis']
-        y_axis = plot_params['axis_labels']['y']['axis']
-        c_axis = plot_params['axis_labels']['c']['axis']
-
-        # Set plot axes to numeric coordinates if needed
-        xds = set_index_coordinates(data, (x_axis, y_axis))
+        axis_labels = self._plot_params['plot']['axis_labels']
 
         # Prefix c_axis name with aggregator
-        xda_name = c_axis
+        xda_name = axis_labels['c']['axis']
         if data_params['aggregator']:
             xda_name = "_".join([data_params['aggregator'], xda_name])
 
-        # Plot unflagged and flagged data
-        xda = xds[data_params['correlated_data']].where(xds.FLAG == 0.0).rename(xda_name)
-        unflagged_plot = self._plot_xda(xda)
-        flagged_xda = xds[data_params['correlated_data']].where(xds.FLAG == 1.0).rename("flagged_" + xda_name)
-        flagged_plot = self._plot_xda(flagged_xda, True)
-
+        # Set plot axes to numeric coordinates if needed
+        xds = set_index_coordinates(data, (axis_labels['x']['axis'], axis_labels['y']['axis']))
+        xda = xds[data_params['correlated_data']].rename(xda_name)
+
+        # Calculate data range for flagged and unflagged data for color limits
+        unflagged_xda = xda.where(xds.FLAG == 0.0)
+        flagged_xda = xda.where(xds.FLAG == 1.0).rename("flagged " + xda_name)
+        unflagged_data_range = (unflagged_xda.min().values.item(), unflagged_xda.max().values.item())
+        flagged_data_range = (flagged_xda.min().values.item(), flagged_xda.max().values.item())
         if is_gui: # update data range for colorbar
-            self._plot_params['data']['data_range'] = (xda.min().values.item(), xda.max().values.item())
+            self._plot_params['data']['data_range'] = unflagged_data_range
+
+        # Plot all data as unflagged (with hover tool), then overlay flagged data
+        unflagged_plot = self._plot_xda(xda, False, unflagged_data_range)
+        flagged_plot = self._plot_xda(flagged_xda, True, flagged_data_range)
 
         # Make Overlay plot
-        return flagged_plot * unflagged_plot
+        return unflagged_plot.opts(tools=['hover']) * flagged_plot.opts(tools=[])
 
     def _get_plot_title(self, data, plot_inputs, ms_name):
         ''' Form string containing ms name and selected values using data (xArray Dataset) '''
@@ -172,34 +172,34 @@ class RasterPlot:
         self._plot_params['plot']['axis_labels'][axis]['label'] = axis_labels[1]
         self._plot_params['plot']['axis_labels'][axis]['ticks'] = axis_labels[2]
 
-    def _plot_xda(self, xda, is_flagged=False):
-        # Returns Quadmesh plot if raster 2D data, Scatter plot if raster 1D data, or None if no data
-        plot_params = self._plot_params['plot']
-        style_params = self._plot_params['style']
+    def _plot_xda(self, xda, is_flagged=False, data_range=None):
+        ''' Return Quadmesh plot if raster 2D data, Scatter plot if raster 1D data, or None if no data '''
+        # Color limits
+        c_lim = self._plot_params['plot']['color_limits']
+        c_lim = data_range if c_lim is None else c_lim
 
-        x_axis = plot_params['axis_labels']['x']['axis']
-        y_axis = plot_params['axis_labels']['y']['axis']
-        c_label = plot_params['axis_labels']['c']['label']
-        c_lim = plot_params['color_limits']
+        axis_labels = self._plot_params['plot']['axis_labels']
+        x_axis = axis_labels['x']['axis']
+        y_axis = axis_labels['y']['axis']
+        c_label = axis_labels['c']['label']
 
+        # Set time formatter
         x_formatter = get_time_formatter() if x_axis == 'time' else None
         y_formatter = get_time_formatter() if y_axis == 'time' else None
 
+        # Show colorbar
+        show_colorbar = False
         if xda.count().values > 0:
-            if is_flagged:
-                show_colorbar = style_params['show_flagged_colorbar']
-            else :
-                show_colorbar = style_params['show_colorbar']
-        else:
-            show_colorbar = False
+            show_colorbar = self._plot_params['style']['show_flagged_colorbar'] if is_flagged else self._plot_params['style']['show_colorbar']
 
+        # Set colorbar label and map
         if is_flagged:
             c_label = "Flagged " + c_label
-            colormap = style_params['flagged_cmap']
-            plot_params['flagged_colorbar'] = show_colorbar
+            colormap = self._plot_params['style']['flagged_cmap']
+            self._plot_params['plot']['flagged_colorbar'] = show_colorbar
         else:
-            colormap = style_params['unflagged_cmap']
-            plot_params['unflagged_colorbar'] = show_colorbar
+            colormap = self._plot_params['style']['unflagged_cmap']
+            self._plot_params['plot']['unflagged_colorbar'] = show_colorbar
 
         if xda[x_axis].size > 1 and xda[y_axis].size > 1:
             # Raster 2D data
@@ -209,16 +209,16 @@ class RasterPlot:
                 clim=c_lim,
                 cmap=colormap,
                 clabel=c_label,
-                title=plot_params['title'],
-                xlabel=plot_params['axis_labels']['x']['label'],
-                ylabel=plot_params['axis_labels']['y']['label'],
+                title=self._plot_params['plot']['title'],
+                xlabel=axis_labels['x']['label'],
+                ylabel=axis_labels['y']['label'],
                 xformatter=x_formatter,
                 yformatter=y_formatter,
-                xticks=plot_params['axis_labels']['x']['ticks'],
-                yticks=plot_params['axis_labels']['y']['ticks'],
+                xticks=axis_labels['x']['ticks'],
+                yticks=axis_labels['y']['ticks'],
                 rot=45, # angle for x axis labels
                 colorbar=show_colorbar,
-                responsive=True, # resize to fill browser window if True
+                responsive=True, # resize to fill browser window
             )
         else:
             # Cannot raster 1D data, use scatter from pandas dataframe
@@ -227,16 +227,16 @@ class RasterPlot:
                 x=x_axis,
                 y=y_axis,
                 c=xda.name,
-                clim=plot_params['color_limits'],
+                clim=c_lim,
                 cmap=colormap,
                 clabel=c_label,
-                title=plot_params['title'],
-                xlabel=plot_params['axis_labels']['x']['label'],
-                ylabel=plot_params['axis_labels']['y']['label'],
+                title=self._plot_params['plot']['title'],
+                xlabel=axis_labels['x']['label'],
+                ylabel=axis_labels['y']['label'],
                 xformatter=x_formatter,
                 yformatter=y_formatter,
-                xticks=plot_params['axis_labels']['x']['ticks'],
-                yticks=plot_params['axis_labels']['y']['ticks'],
+                xticks=axis_labels['x']['ticks'],
+                yticks=axis_labels['y']['ticks'],
                 rot=45,
                 marker='s', # square
                 responsive=True,

{vidavis-0.1.3 → vidavis-0.1.5}/src/vidavis/plot/ms_plot/_raster_plot_gui.py

@@ -26,10 +26,10 @@ def create_raster_gui(callbacks, plot_info, empty_plot):
             pn.pane.HoloViews(empty_plot),             # Row[0] plot
             pn.WidgetBox(sizing_mode='stretch_width'), # Row[1] cursor location
         )),
-        ('Plot Inputs', pn.Column()),                                      # Tabs[1]
-        ('Locate Selected Points', pn.Feed(sizing_mode='stretch_height')), # Tabs[2]
-        ('Locate Selected Box', pn.Feed(sizing_mode='stretch_height')),    # Tabs[3]
-        ('Plot Settings', pn.Column(                                       # Tabs[4]
+        ('Plot Inputs', pn.Column()),                             # Tabs[1]
+        ('Locate Points', pn.Feed(sizing_mode='stretch_height')), # Tabs[2]
+        ('Locate Box', pn.Feed(sizing_mode='stretch_height')),    # Tabs[3]
+        ('Plot Settings', pn.Column(                              # Tabs[4]
             pn.Spacer(height=25), # Column[0]
             selectors,            # Column[1] selectors
             init_plot,            # Column[2] plot button and spinner