vidavis 0.0.13__py3-none-any.whl → 0.0.14__py3-none-any.whl

vidavis/plot/ms_plot/_locate_points.py

@@ -10,8 +10,9 @@ import panel as pn
 
 from vidavis.plot.ms_plot._ms_plot_constants import TIME_FORMAT
 
-def cursor_changed(x, y, last_cursor):
+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):
@@ -21,7 +22,7 @@ def cursor_changed(x, y, last_cursor):
 def points_changed(data, last_points):
     ''' Check whether point positions changed '''
     # No data = {'x': [], 'y': []}
-    if len(data['x']) == 0 and len(data['y']) == 0:
+    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
@@ -36,7 +37,67 @@ def box_changed(bounds, last_box):
         return False # same box
     return True # new box, box changed, or box deleted
 
-def locate_point(xds, position, vis_axis):
+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) '''
+    # Convert plot values to selection values to select plot data
+    cursor_locate_box.clear()
+
+    x, y = cursor
+    x_axis, y_axis, vis_axis = plot_axes
+    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_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_column, logger):
+    ''' Show data values for points in point_draw in tab and log '''
+    points_tab_column.clear()
+    if data:
+        x_axis, y_axis, vis_axis = plot_axes
+        logger.info("Locate selected points:")
+
+        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_column.append(location_layout)
+            points_tab_column.append(pn.layout.Divider())
+
+            # Format and add to log
+            location_list = [f"{static_text.name}={static_text.value}" for static_text in point_location]
+            logger.info(", ".join(location_list))
+
+def update_box_location(bounds, plot_axes, xds, box_tab_column, logger):
+    ''' Show data values for points in box_select in tab and log '''
+    box_tab_column.clear()
+    if bounds:
+        x_axis, y_axis, vis_axis = plot_axes
+        box_bounds = {x_axis: (bounds[0], bounds[2]), y_axis: (bounds[1], bounds[3])}
+        npoints, point_locations = _locate_box(xds, box_bounds, vis_axis)
+
+        message = f"Locate {npoints} points"
+        message += " (only first 100 shown):" if npoints > 100 else ":"
+        logger.info(message)
+        box_tab_column.append(pn.pane.Str(message))
+
+        for point in point_locations:
+            # Format and add to box locate column
+            location_layout = _layout_point_location(point)
+            box_tab_column.append(location_layout)
+            box_tab_column.append(pn.layout.Divider())
+
+            # Format and add to log
+            location_list = [f"{static_text.name}={static_text.value}" for static_text in point]
+            logger.info(", ".join(location_list))
+
+def _locate_point(xds, position, vis_axis):
     '''
         Get cursor location as values of coordinates and data vars.
             xds (Xarray Dataset): data for plot
@@ -48,15 +109,18 @@ def locate_point(xds, position, vis_axis):
     static_text_list = []
     values, units = _get_point_location(xds, position, vis_axis)
 
-    # Rename baseline coordinate names to not confuse user for selection
-    baseline_names = {'baseline': 'baseline_index', 'baseline_name': 'baseline', 'antenna_name': 'antenna_index', 'antenna': 'antenna_name'}
+    # List indexed coordinate int value with with str value
+    index_coords = {'baseline': 'baseline_name', 'antenna_name': 'antenna', 'polarization': 'polarization_name'}
     for name, value in values.items():
-        name = baseline_names[name] if name in baseline_names else name
+        if name in index_coords.values():
+            continue
+        if name in index_coords and isinstance(value, int):
+            value = f"{values[index_coords[name]]} ({value})" # append name to index
         static_text = _get_location_text(name, value, units)
         static_text_list.append(static_text)
     return static_text_list
 
-def locate_box(xds, bounds, vis_axis):
+def _locate_box(xds, bounds, vis_axis):
     '''
         Get location of each point in box bounds as values of coordinate and data vars.
             xds (Xarray Dataset): data for plot
@@ -83,7 +147,7 @@ def locate_box(xds, bounds, vis_axis):
             for y in sel_xds[y_coord].values:
                 for x in sel_xds[x_coord].values:
                     position = {x_coord: x, y_coord: y}
-                    points.append(locate_point(sel_xds, position, vis_axis))
+                    points.append(_locate_point(sel_xds, position, vis_axis))
                     counter += 1
                     if counter == 100:
                         break
@@ -183,3 +247,21 @@ def _get_location_text(name, value, units):
             units.pop(name) # no unit for datetime string
     unit = units[name] if name in units else ""
     return pn.widgets.StaticText(name=name, value=f"{value} {unit}")
+
+def _layout_point_location(text_list):
+    ''' Layout list of StaticText in row of columns containing 3 rows '''
+    location_row = pn.Row()
+    location_col = pn.Column()
+
+    for static_text in text_list:
+        # 3 entries per column; append to row and start new column
+        if len(location_col.objects) == 3:
+            location_row.append(location_col)
+            location_col = pn.Column()
+
+        static_text.margin = (0, 10) # default (5, 10)
+        location_col.append(static_text)
+
+    # Add last column
+    location_row.append(location_col)
+    return location_row

vidavis/plot/ms_plot/_ms_plot.py

@@ -20,6 +20,7 @@ except ImportError:
     _HAVE_TOOLVIPER = False
 
 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.toolbox import AppContext, get_logger
 
 class MsPlot:
@@ -45,39 +46,42 @@ class MsPlot:
         # Set up temp dir for output html files
         self._app_context = AppContext(app_name)
 
+        # Initialize plot inputs and params
+        self._plot_inputs = None # object to manage plot inputs
+
+        # Initialize plots
+        self._plot_init = False
+        self._plots = []
+        self._last_plot = None
+        self._plot_params = [] # for plot inputs tab
+
         if show_gui:
             # Enable "toast" notifications
             pn.config.notifications = True
             self._toast = None # for destroy() with new plot or new notification
 
             # Initialize gui panel for callbacks
+            self._gui_plot_data = None
+            self._gui_selection = {}
             self._gui_layout = None
             self._first_gui_plot = True
-            self._last_gui_plot = None
-            self._gui_plot_data = None
 
-            # For _update_plot callback: check which inputs and point positions changed
+            # For _update_plot callback: check if inputs changed
             self._last_plot_inputs = None
             self._last_style_inputs = None
-            self._last_cursor = None
-            self._last_points = None
-            self._last_box = None
 
-        # Initialize plot inputs and params
-        self._plot_inputs = {'selection': {}}
-        self._plot_params = None
+        # For locate callback: check if points changed
+        self._plot_axes = None
+        self._last_cursor = None
+        self._last_points = None
+        self._last_box = None
 
-        # Initialize plots
-        self._plot_init = False
-        self._plots_locked = False
-        self._plots = []
-
-        # Initialize show() panel for callbacks
+        # Initialize non-gui show() panel for callbacks
         self._show_layout = None
         self._plot_data = None
 
         # Set data (if ms)
-        self._data = None
+        self._ms_data = None
         self._ms_info = {}
         self._set_ms(ms)
 # pylint: enable=too-many-arguments, too-many-positional-arguments
@@ -94,15 +98,15 @@ class MsPlot:
                                  'field_name', 'source_name', 'field_coords', 'start_frequency', 'end_frequency'
             Returns: list of unique values when single column is requested, else None
         '''
-        if self._data:
-            self._data.summary(data_group, columns)
+        if self._ms_data:
+            self._ms_data.summary(data_group, columns)
         else:
             self._logger.error("Error: MS path has not been set")
 
     def data_groups(self):
         ''' Returns set of data groups from all ProcessingSet ms_xds. '''
-        if self._data:
-            return self._data.data_groups()
+        if self._ms_data:
+            return self._ms_data.data_groups()
         self._logger.error("Error: MS path has not been set")
         return None
 
@@ -111,8 +115,8 @@ class MsPlot:
             Dimension options include 'time', 'baseline' (for visibility data), 'antenna' (for spectrum data), 'antenna1',
                 'antenna2', 'frequency', 'polarization'.
         '''
-        if self._data:
-            return self._data.get_dimension_values(dimension)
+        if self._ms_data:
+            return self._ms_data.get_dimension_values(dimension)
         self._logger.error("Error: MS path has not been set")
         return None
 
@@ -120,8 +124,8 @@ class MsPlot:
         ''' Plot antenna positions.
                 label_antennas (bool): label positions with antenna names.
         '''
-        if self._data:
-            self._data.plot_antennas(label_antennas)
+        if self._ms_data:
+            self._ms_data.plot_antennas(label_antennas)
         else:
             self._logger.error("Error: MS path has not been set")
 
@@ -130,23 +134,33 @@ class MsPlot:
                 data_group (str): data group to use for field and source xds.
                 label_fields (bool): label all fields on the plot if True, else label central field only
         '''
-        if self._data:
-            self._data.plot_phase_centers(data_group, label_fields)
+        if self._ms_data:
+            self._ms_data.plot_phase_centers(data_group, label_fields)
         else:
             self._logger.error("Error: MS path has not been set")
 
     def clear_plots(self):
         ''' Clear plot list '''
-        while self._plots_locked:
-            time.sleep(1)
         self._plots.clear()
+        self._plot_params.clear()
+        self._plot_axes = None
+
+    def unlink_plot_streams(self):
+        ''' Disconnect streams when plot data is going to be replaced '''
+        if self._show_layout and len(self._show_layout.objects) == 4:
+            # Remove dmap (streams with callback) from previous plot
+            self._show_layout[0][0] = self._last_plot.opts(tools=['hover'])
+            # Remove locate widgets
+            self._show_layout[0].pop(1) # cursor locate box
+            self._show_layout.pop(3)    # box locate tab
+            self._show_layout.pop(2)    # points locate tab
 
     def clear_selection(self):
         ''' Clear data selection and restore original ProcessingSet '''
-        if self._data:
-            self._data.clear_selection()
+        if self._ms_data:
+            self._ms_data.clear_selection()
 
-        self._plot_inputs['selection'] = {}
+        self._plot_inputs.remove_input('selection')
 
     def show(self):
         ''' 
@@ -155,24 +169,61 @@ class MsPlot:
         if not self._plots:
             raise RuntimeError("No plots to show.  Run plot() to create plot.")
 
-        # Do not delete plot list until rendered
-        self._plots_locked = True
-
         # Single plot or combine plots into layout using subplots (rows, columns)
-        layout_plot = self._layout_plots(self._plot_inputs['subplots'])
-
-        # Render plot as Bokeh Figure or GridPlot so can show() in script without tying up thread
-        bokeh_fig = hv.render(layout_plot)
+        subplots = self._plot_inputs.get_input('subplots')
+        layout_plot = self._layout_plots(subplots)
 
-        self._plots_locked = False
+        # Add plot inputs column tab
+        inputs_column = None
         if self._plot_params:
-            # Show plot and plot inputs in tabs
-            column = pn.Column()
-            for param in self._plot_params:
-                column.append(pn.pane.Str(param))
-            self._show_layout = pn.Tabs(('Plot', bokeh_fig), ('Plot Inputs', column))
+            inputs_column = pn.Column()
+            self._fill_inputs_column(inputs_column)
+
+        # Show plot and plot inputs in tabs
+        if self._plot_inputs.is_layout():
+            self._show_layout = pn.Tabs(('Plot', layout_plot))
+            if inputs_column:
+                self._show_layout.append(('Plot Inputs', inputs_column))
         else:
-            self._show_layout = pn.pane.Bokeh(bokeh_fig)
+            plot = layout_plot.opts(
+                hv.opts.QuadMesh(
+                    tools=['hover', 'box_select'],
+                    selection_fill_alpha=0.2,    # dim selected areas of plot
+                    nonselection_fill_alpha=1.0, # do not dim unselected areas of plot
+                )
+            )
+            # Add DynamicMap for streams for single plot
+            points = hv.Points([]).opts(
+                size=5,
+                fill_color='white'
+            )
+            dmap = hv.DynamicMap(
+                self._locate,
+                streams=[
+                    hv.streams.PointerXY(),              # cursor location (x, y)
+                    hv.streams.PointDraw(source=points), # fixed points location (data)
+                    hv.streams.BoundsXY()                # box location (bounds)
+                ]
+            )
+
+            # Create panel layout
+            self._show_layout = pn.Tabs(
+                ('Plot', pn.Column(
+                    plot * dmap * points,
+                    pn.WidgetBox(), # cursor info
+                    )
+                ),
+                sizing_mode='stretch_width',
+            )
+            if inputs_column:
+                self._show_layout.append(('Plot Inputs', inputs_column))
+            self._show_layout.append(('Locate Selected Points', pn.Column()))
+            self._show_layout.append(('Locate Selected Box', pn.Column()))
+
+            # return value for locate callback
+            self._last_plot = plot
+
+        # Show panel layout
         self._show_layout.show(title=self._app_name, threaded=True)
 
     def save(self, filename='ms_plot.png', fmt='auto', width=900, height=600):
@@ -193,11 +244,14 @@ class MsPlot:
 
         # Combine plots into layout using subplots (rows, columns) if not single plot.
         # Set fixed size for export.
-        layout_plot = self._layout_plots(self._plot_inputs['subplots'], (width, height))
+        subplots = self._plot_inputs.get_input('subplots')
+        layout_plot = self._layout_plots(subplots, (width, height))
 
-        if not isinstance(layout_plot, hv.Layout) and self._plot_inputs['iter_axis']:
+        iter_axis = self._plot_inputs.get_input('iter_axis')
+        if not isinstance(layout_plot, hv.Layout) and iter_axis:
             # Save iterated plots individually, with index appended to filename
-            plot_idx = 0 if self._plot_inputs['iter_range'] is None else self._plot_inputs['iter_range'][0]
+            iter_range = self._plot_inputs.get_input('iter_range')
+            plot_idx = 0 if iter_range is None else iter_range[0]
             for plot in self._plots:
                 exportname = f"{name}_{plot_idx}{ext}"
                 self._save_plot(plot, exportname, fmt)
@@ -266,22 +320,22 @@ class MsPlot:
             Return whether ms changed (false if ms_path is None, not set yet), even if error. '''
         self._ms_info['ms'] = ms_path
         ms_error = ""
-        if not ms_path or (self._data and self._data.is_ms_path(ms_path)):
+        if not ms_path or (self._ms_data and self._ms_data.is_ms_path(ms_path)):
             return False
 
         try:
             # Set new MS data
-            self._data = MsData(ms_path, self._logger)
-            data_path = self._data.get_path()
+            self._ms_data = MsData(ms_path, self._logger)
+            data_path = self._ms_data.get_path()
             self._ms_info['ms'] = data_path
             root, ext = os.path.splitext(os.path.basename(data_path))
             while ext != '':
                 root, ext = os.path.splitext(root)
             self._ms_info['basename'] = root
-            self._ms_info['data_dims'] = self._data.get_data_dimensions()
+            self._ms_info['data_dims'] = self._ms_data.get_data_dimensions()
         except RuntimeError as e:
             ms_error = str(e)
-            self._data = None
+            self._ms_data = None
         if ms_error:
             self._notify(ms_error, 'error', 0)
         return True
@@ -320,4 +374,70 @@ class MsPlot:
                 del plot_inputs[key]
             except KeyError:
                 pass
-        self._plot_params = sorted([f"{key}={value}" for key, value in plot_inputs.items()])
+        if not self._plot_params:
+            self._plot_params = plot_inputs
+        else:
+            for param, value in self._plot_params.items():
+                if plot_inputs[param] != value:
+                    if isinstance(value, list):
+                        # append new value to existing list if not repeat
+                        if plot_inputs[param] != value[-1]:
+                            value.append(plot_inputs[param])
+                    else:
+                        # make list to include new value
+                        value = [value, plot_inputs[param]]
+                    self._plot_params[param] = value
+
+    def _fill_inputs_column(self, inputs_tab_column):
+        ''' Format plot inputs and list in Panel column '''
+        if self._plot_params:
+            inputs_tab_column.clear()
+            plot_params = sorted([f"{key}={value}" for key, value in self._plot_params.items()])
+            for param in plot_params:
+                str_pane = pn.pane.Str(param)
+                str_pane.margin = (0, 10)
+                inputs_tab_column.append(str_pane)
+
+    def _get_plot_axes(self):
+        ''' Return x, y, vis axes '''
+        if not self._plot_axes:
+            x_axis = self._plot_inputs.get_input('x_axis')
+            y_axis = self._plot_inputs.get_input('y_axis')
+            vis_axis = self._plot_inputs.get_input('vis_axis')
+            self._plot_axes = (x_axis, y_axis, vis_axis)
+        return self._plot_axes
+
+    def _locate(self, x, y, data, bounds):
+        ''' Callback for all show plot streams '''
+        self._locate_cursor(x, y, self._plot_data, self._show_layout)
+        self._locate_points(data, self._plot_data, self._show_layout)
+        self._locate_box(bounds, self._plot_data, self._show_layout)
+        return self._last_plot
+
+    def _locate_cursor(self, x, y, plot_data, tabs):
+        ''' Show location from cursor position in cursor locate box '''
+        cursor = (x, y)
+        if cursor_changed(cursor, self._last_cursor):
+            # new cursor position - update cursor location box
+            plot_axes = self._get_plot_axes()
+            cursor_box = tabs[0][1]
+            update_cursor_location(cursor, plot_axes, plot_data, cursor_box)
+            self._last_cursor = cursor
+
+    def _locate_points(self, point_data, plot_data, tabs):
+        ''' Show points locations from point_draw tool '''
+        if points_changed(point_data, self._last_points):
+            # new points position - update selected points location tab
+            plot_axes = self._get_plot_axes()
+            points_tab = tabs[2]
+            update_points_location(point_data, plot_axes, plot_data, points_tab, self._logger)
+            self._last_points = point_data
+
+    def _locate_box(self, box_bounds, plot_data, tabs):
+        ''' Show points locations in box from box_select tool '''
+        if box_changed(box_bounds, self._last_box):
+            # new box_select position - update selected box location tab
+            plot_axes = self._get_plot_axes()
+            box_tab = tabs[3]
+            update_box_location(box_bounds, plot_axes, plot_data, box_tab, self._logger)
+            self._last_box = box_bounds

vidavis/plot/ms_plot/_raster_plot_inputs.py

@@ -0,0 +1,114 @@
+'''
+Class to check and hold inputs for raster plot.
+'''
+
+from vidavis.plot.ms_plot._check_raster_inputs import check_inputs
+
+class RasterPlotInputs:
+    '''
+        Class to set inputs for raster plots from MsRaster functions or GUI.
+    '''
+
+    def __init__(self):
+        self._plot_inputs = {}
+
+    def get_inputs(self):
+        ''' Getter for stored plot inputs '''
+        return self._plot_inputs
+
+    def get_input(self, name):
+        ''' Getter for stored plot input by name '''
+        try:
+            return self._plot_inputs[name]
+        except KeyError:
+            return None
+
+    def set_input(self, name, value):
+        ''' Set plot input by name and value '''
+        self._plot_inputs[name] = value
+        if name == 'selection' and 'data_group_name' in value:
+            self._plot_inputs['data_group'] = value['data_group_name']
+
+    def set_selection(self, selection):
+        ''' Add selection dict to existing selection in plot inputs '''
+        if 'selection' not in self._plot_inputs:
+            self._plot_inputs['selection'] = {}
+        self._plot_inputs['selection'] |= selection
+        if 'data_group_name' in selection:
+            self._plot_inputs['data_group'] = selection['data_group_name']
+
+    def get_selection(self, key):
+        ''' Return value for selection key '''
+        try:
+            return self.get_input('selection')[key]
+        except (TypeError, KeyError):
+            # TypeError: get_input returned None for 'selection'
+            # KeyError: key not in selection
+            return None
+
+    def set_inputs(self, plot_inputs):
+        ''' Setter for storing plot inputs from MsRaster.plot() '''
+        check_inputs(plot_inputs)
+        for key, val in plot_inputs.items():
+            self._plot_inputs[key] = val
+
+    def remove_input(self, name):
+        ''' Remove plot input with name, if it exists '''
+        try:
+            del self._plot_inputs[name]
+        except KeyError:
+            pass
+
+    def check_inputs(self):
+        ''' Check input values are valid, adjust for data dims '''
+        check_inputs(self._plot_inputs)
+
+    def is_layout(self):
+        ''' Determine if plot is a layout using plot inputs '''
+        # Check if subplots is a layout
+        subplots = self.get_input('subplots')
+        if subplots is None or subplots == (1, 1):
+            return False
+
+        # Subplots is a layout, check if multi plot
+        if not self.get_input('clear_plots'):
+            return True
+
+        # Check if iteration set and iter_range more than one plot
+        iter_length = 0
+        if self.get_input('iter_axis') is not None:
+            iter_range = self.get_input('iter_range')
+            if iter_range is None or iter_range[1] == -1:
+                iter_range = self.get_input('auto_iter_range')
+            iter_length = len(range(iter_range[0], iter_range[1] + 1))
+        return iter_length > 1
+
+    #--------------
+    # GUI CALLBACKS
+    #--------------
+
+    def set_color_inputs(self, color_mode, color_range):
+        ''' Set style params from gui '''
+        color_mode = color_mode.split()[0]
+        color_mode = None if color_mode == 'No' else color_mode
+        self.set_input('color_mode', color_mode)
+        self.set_input('color_range', color_range)
+
+    def set_axis_inputs(self, x_axis, y_axis, vis_axis):
+        ''' Set plot axis inputs from gui '''
+        self.set_input('x_axis', x_axis)
+        self.set_input('y_axis', y_axis)
+        self.set_input('vis_axis', vis_axis)
+
+    def set_aggregation_inputs(self, aggregator, agg_axes):
+        ''' Set aggregation inputs from gui '''
+        aggregator = None if aggregator== 'None' else aggregator
+        self.set_input('aggregator', aggregator)
+        self.set_input('agg_axis', agg_axes) # ignored if aggregator not set
+
+    def set_iteration_inputs(self, iter_axis, iter_range, subplot_rows, subplot_columns):
+        ''' Set iteration inputs from gui '''
+        iter_axis = None if iter_axis == 'None' else iter_axis
+        self.set_input('iter_axis', iter_axis)
+        self.set_input('iter_range', iter_range)
+        self.set_input('subplots', (subplot_rows, subplot_columns))

{vidavis-0.0.13.dist-info → vidavis-0.0.14.dist-info}/METADATA

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

{vidavis-0.0.13.dist-info → vidavis-0.0.14.dist-info}/RECORD

@@ -1,7 +1,7 @@
 vidavis/LICENSE.rst,sha256=qzGpkvhDzf_MgF1PIn6rCmYPrcEhkfrBUchosLJj-U4,26371
 vidavis/__init__.py,sha256=FVM92yTXUplR7tVHiGao0Y3Hd80pRTrwVIYDLjzICws,1709
 vidavis/apps/__init__.py,sha256=ZQ5v1VFtjn3ztmuOHLOk5WbC1uLNIgL9rbHQ4v0zJwY,87
-vidavis/apps/_ms_raster.py,sha256=bWe7N7lbwNYzPl1n-_Y_qBErDddxVe8jnPRYqOxylSI,48397
+vidavis/apps/_ms_raster.py,sha256=MtW55gRm9EYKR-E86-YrfSnNiYg-xa6WJNar-0-Rsac,43139
 vidavis/bokeh/__init__.py,sha256=gdPPxBCe0enCSjvPFxkgMlhpVnAMFXKcw9GN28tVdXM,95
 vidavis/bokeh/_palette.py,sha256=gzfJHuUgqxd8hJpZe-gQPFTCPq9f5I8uLEkHAK5FNDM,2480
 vidavis/data/__init__.py,sha256=-RDRe0PYK6vPlhdRV2Dy1vGbnDGoXWDATmfxaR-gXcE,48
@@ -19,21 +19,22 @@ vidavis/data/measurement_set/processing_set/_xds_data.py,sha256=qLO2VkLINkSAQ7CG
 vidavis/plot/__init__.py,sha256=thxe5vAGdpEiqoKPHLJoWUqKMVrUVx0ajpsGf5pVP98,95
 vidavis/plot/ms_plot/__init__.py,sha256=wY0_7gY9M6K1D6tKQsr89L_uSs3seJlD-uicx7dx5Mo,74
 vidavis/plot/ms_plot/_check_raster_inputs.py,sha256=a7u5wlDKTxWYW36-Xp3xd4c756SbYURdFkGHbUaX440,4786
-vidavis/plot/ms_plot/_locate_points.py,sha256=GvuS5kDhIYancc314ofLoYtoRhT_jagG8HpzchhdPds,7474
-vidavis/plot/ms_plot/_ms_plot.py,sha256=RShzvWzHq7iA9awuaWO8GiB1NkWuYkcNOMdToLWPnes,13246
+vidavis/plot/ms_plot/_locate_points.py,sha256=f2sOeq1Ba6SR7uk7pX2vS2TLPsQsWZti2VJkOcFx6Gw,10899
+vidavis/plot/ms_plot/_ms_plot.py,sha256=B0_81JtBD9k7M8frwlgoJNH6vZzW17aGmytPjD_xQqw,18706
 vidavis/plot/ms_plot/_ms_plot_constants.py,sha256=cX_TQhKJ3hJzPuRYmuRJxue1sjq82yl_ZN2_w6TshmI,930
 vidavis/plot/ms_plot/_ms_plot_selectors.py,sha256=BZQwARvMPdk78n6Rh2tOaSc8GenZBrxHZb14oFD9gJM,10785
 vidavis/plot/ms_plot/_plot_inputs.py,sha256=pZL63n9FHSoo9cntf7lppQj44nkpiwnCz6VH-9Oh6ho,671
 vidavis/plot/ms_plot/_raster_plot.py,sha256=lNa9i_eJ8F8Fc2zcHLRcaxKKOELk3x_QmXT__T76pg8,10999
 vidavis/plot/ms_plot/_raster_plot_gui.py,sha256=Kb0BLmkwtYHCqlVaSipbTTStst8RYggqwf1Wf5v8F4Q,4261
+vidavis/plot/ms_plot/_raster_plot_inputs.py,sha256=AMIvEz2b4QLH03P6EJXOAnkQ-v2uNKEukdaoA6g070Y,4166
 vidavis/plot/ms_plot/_time_ticks.py,sha256=j-DcPh7RfGE8iX2bPjLQDQPIbiAbmjiEWQnKmdMWA3I,1773
 vidavis/plot/ms_plot/_xds_plot_axes.py,sha256=EeWvAbiKV33nEWdI8V3M0uwLTnycq4bFYBOyVWkxCu0,4429
 vidavis/toolbox/__init__.py,sha256=jqFa-eziVz_frNnXxwjJFK36qNpz1H38s-VlpBcq-R8,1402
 vidavis/toolbox/_app_context.py,sha256=H7gtF8RrAH46FqDcMobv3KM1Osbnapgu6aTG-m3VCWA,3049
 vidavis/toolbox/_logging.py,sha256=OEisrd8FM8VTNBMc7neLh9ekelf29ZILYB5pScebly0,2739
 vidavis/toolbox/_static.py,sha256=HJLMtClppgOJXWAtV6Umn5EqN80u0oZiIouQ1JsB9PM,2346
-vidavis/__version__.py,sha256=6iFz7cldtJZlw_FSwnt97X1e8jfQ-fdVhcVMqnAiWh8,22
-vidavis-0.0.13.dist-info/WHEEL,sha256=B19PGBCYhWaz2p_UjAoRVh767nYQfk14Sn4TpIZ-nfU,87
-vidavis-0.0.13.dist-info/METADATA,sha256=7fBkDctO-V9veQD-m1BbnimzfHgH-PXvEvmhNE_7z3I,2238
-vidavis-0.0.13.dist-info/licenses/LICENSE,sha256=IMF9i4xIpgCADf0U-V1cuf9HBmqWQd3qtI3FSuyW4zE,26526
-vidavis-0.0.13.dist-info/RECORD,,
+vidavis/__version__.py,sha256=DT3lXVWSM0vxCDfBsBbQ4k1SOUtDSFBhl094H35FE2w,22
+vidavis-0.0.14.dist-info/WHEEL,sha256=B19PGBCYhWaz2p_UjAoRVh767nYQfk14Sn4TpIZ-nfU,87
+vidavis-0.0.14.dist-info/METADATA,sha256=fZDo9_lUcwhVToPrllG6fE5SJj0XcyDcgbzoOvVf_zY,2238
+vidavis-0.0.14.dist-info/licenses/LICENSE,sha256=IMF9i4xIpgCADf0U-V1cuf9HBmqWQd3qtI3FSuyW4zE,26526
+vidavis-0.0.14.dist-info/RECORD,,