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

vidavis/plot/ms_plot/_check_raster_inputs.py

@@ -0,0 +1,107 @@
+'''
+Check inputs to MsRaster plot() or its GUI
+'''
+
+from vidavis.plot.ms_plot._ms_plot_constants import VIS_AXIS_OPTIONS, AGGREGATOR_OPTIONS
+
+def check_inputs(inputs):
+    ''' Check plot input types, and axis (plot, agg, iter) input values. '''
+    _set_baseline_antenna_axis(inputs)
+    _check_axis_inputs(inputs)
+    _check_agg_inputs(inputs)
+    _check_color_inputs(inputs)
+    _check_other_inputs(inputs)
+
+def _set_baseline_antenna_axis(inputs):
+    ''' Set baseline axis to dimension in data_dims '''
+    if 'data_dims' not in inputs:
+        return
+
+    data_dims = inputs['data_dims']
+    baseline_dim = 'antenna_name' if 'antenna_name' in data_dims else 'baseline'
+
+    # Convert baseline axis to existing baseline dimension
+    baseline_dims = ['baseline', 'antenna_name']
+    for axis in ['x_axis', 'y_axis', 'iter_axis', 'agg_axis']:
+        if inputs[axis] in baseline_dims:
+            inputs[axis] = baseline_dim
+
+def _check_axis_inputs(inputs):
+    ''' Check x_axis, y_axis, vis_axis, and iter_axis inputs. '''
+    x_axis = inputs['x_axis']
+    y_axis = inputs['y_axis']
+    if x_axis == y_axis:
+        raise ValueError(f"Invalid parameter values: x_axis {x_axis} cannot be same as y_axis {y_axis}.")
+
+    iter_axis = inputs['iter_axis']
+    if iter_axis and iter_axis in (x_axis, y_axis):
+        raise ValueError(f"Invalid parameter value: iter_axis {iter_axis} cannot be x_axis ({x_axis}) or y_axis ({y_axis}).")
+
+    data_dims = inputs['data_dims'] if 'data_dims' in inputs else None
+    if data_dims:
+        if x_axis not in data_dims or y_axis not in data_dims:
+            raise ValueError(f"Invalid parameter value: x and y axis must be a data dimension in {data_dims}.")
+        if iter_axis and iter_axis not in data_dims:
+            raise ValueError(f"Invalid parameter value: iter_axis {iter_axis} must be a data dimension in {data_dims}.")
+
+    vis_axis = inputs['vis_axis']
+    if vis_axis not in VIS_AXIS_OPTIONS:
+        raise ValueError(f"Invalid parameter value: vis_axis {vis_axis} must be one of {VIS_AXIS_OPTIONS}")
+
+def _check_agg_inputs(inputs):
+    ''' Check aggregator and agg_axis. Set agg_axis if not set. '''
+    aggregator = inputs['aggregator']
+    agg_axis = inputs['agg_axis']
+
+    x_axis = inputs['x_axis']
+    y_axis = inputs['y_axis']
+    data_dims = inputs['data_dims'] if 'data_dims' in inputs else None
+
+    if aggregator and aggregator not in AGGREGATOR_OPTIONS:
+        raise ValueError(f"Invalid parameter value: aggregator {aggregator} must be None or one of {AGGREGATOR_OPTIONS}.")
+
+    if agg_axis:
+        if not isinstance(agg_axis, str) and not isinstance(agg_axis, list):
+            raise TypeError(f"Invalid parameter type: agg_axis {agg_axis} must be str or list.")
+
+        # Make agg_axis a list
+        if isinstance(agg_axis, str):
+            agg_axis = [agg_axis]
+
+        for axis in agg_axis:
+            if axis in (x_axis, y_axis):
+                raise ValueError(f"Invalid parameter value: agg_axis {agg_axis} cannot be x_axis ({x_axis}) or y_axis ({y_axis}).")
+            if data_dims and axis not in data_dims:
+                raise ValueError(f"Invalid parameter value: agg_axis {axis} must be a data dimension in {data_dims}.")
+    elif aggregator and data_dims:
+        # Set agg_axis to non-plotted dim axes
+        agg_axis = data_dims.copy()
+        agg_axis.remove(x_axis)
+        agg_axis.remove(y_axis)
+        if 'iter_axis' in inputs and inputs['iter_axis']:
+            agg_axis.remove(inputs['iter_axis'])
+    inputs['agg_axis'] = agg_axis
+
+def _check_color_inputs(inputs):
+    if inputs['color_mode']:
+        color_mode = inputs['color_mode'].lower()
+        valid_color_modes = ['auto', 'manual']
+        if color_mode not  in valid_color_modes:
+            raise ValueError(f"Invalid parameter value: color_mode {color_mode} must be None or one of {valid_color_modes}.")
+        inputs['color_mode'] = color_mode
+
+    if inputs['color_range']:
+        if not (isinstance(inputs['color_range'], tuple) and len(inputs['color_range']) == 2):
+            raise ValueError("Invalid parameter type: color_range must be None or a tuple of (min, max).")
+
+def _check_other_inputs(inputs):
+    if inputs['iter_range']:
+        if not (isinstance(inputs['iter_range'], tuple) and len(inputs['iter_range']) == 2):
+            raise ValueError("Invalid parameter type: iter_range must be None or a tuple of (start, end).")
+
+    if inputs['subplots']:
+        if not (isinstance(inputs['subplots'], tuple) and len(inputs['subplots']) == 2):
+            raise ValueError("Invalid parameter type: subplots must be None or a tuple of (rows, columns).")
+
+    if inputs['title'] and not isinstance(inputs['title'], str):
+        raise TypeError("Invalid parameter type: title must be None or a string.")

vidavis/plot/ms_plot/_locate_points.py

@@ -10,7 +10,94 @@ import panel as pn
 
 from vidavis.plot.ms_plot._ms_plot_constants import TIME_FORMAT
 
-def locate_point(xds, position, vis_axis):
+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 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
@@ -22,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
@@ -47,7 +137,7 @@ def locate_box(xds, bounds, vis_axis):
             selection = {}
             for coord, val in bounds.items():
                 # Round index values to int for selection
-                selection[coord] = slice(_round_index_value(coord, val[0]), _round_index_value(coord, val[1]))
+                selection[coord] = slice(_get_selection_value(coord, val[0]), _get_selection_value(coord, val[1]))
             sel_xds = xds.sel(indexers=None, method=None, tolerance=None, drop=False, **selection)
 
             x_coord, y_coord = bounds.keys()
@@ -57,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
@@ -81,9 +171,9 @@ def _get_point_location(xds, position, vis_axis):
 
     if xds:
         try:
-            # Round index coordinates to int for selection
             for coord, value in position.items():
-                position[coord] = _round_index_value(coord, value)
+                # 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:
@@ -112,9 +202,15 @@ def _get_point_location(xds, position, vis_axis):
         values[vis_axis.upper()] = values.pop('VISIBILITY')
     return values, units
 
-def _round_index_value(coord, value):
-    ''' Round index coordinates to int for selecction '''
-    return round(value) if coord in ['baseline', 'antenna_name', 'polarization'] else value
+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) '''
@@ -151,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

@@ -6,7 +6,7 @@ import os
 import time
 
 from bokeh.io import export_png, export_svg
-from bokeh.plotting import save, show
+from bokeh.plotting import save
 import hvplot
 import holoviews as hv
 import numpy as np
@@ -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,28 +46,42 @@ class MsPlot:
         # Set up temp dir for output html files
         self._app_context = AppContext(app_name)
 
-        if show_gui:
-            # Enable "toast" notifications
-            pn.config.notifications = True
-            self._toast = None # for destroy() with new plot or new notification
-
         # Initialize plot inputs and params
-        self._plot_inputs = {'selection': {}}
-        self._plot_params = None
+        self._plot_inputs = None # object to manage plot inputs
 
         # Initialize plots
         self._plot_init = False
-        self._plots_locked = False
         self._plots = []
+        self._last_plot = None
+        self._plot_params = [] # for plot inputs tab
 
-        # Initialize gui
         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
+
+            # For _update_plot callback: check if inputs changed
+            self._last_plot_inputs = None
+            self._last_style_inputs = 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 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
@@ -83,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
 
@@ -100,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
 
@@ -109,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")
 
@@ -119,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):
         ''' 
@@ -144,25 +169,62 @@ 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))
-            tabs = pn.Tabs(('Plot', bokeh_fig), ('Plot Inputs', column))
-            tabs.show(title=self._app_name, threaded=True)
+            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:
-            show(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):
         '''
@@ -182,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)
@@ -255,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
@@ -309,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/_plot_inputs.py

@@ -0,0 +1,19 @@
+''' Utilities for inputs to MeasurementSet plots '''
+
+def inputs_changed(plot_inputs, last_plot_inputs):
+    ''' Check if inputs changed and need new plot '''
+    if not last_plot_inputs:
+        return True
+
+    for key, val in plot_inputs.items():
+        if not _values_equal(val, last_plot_inputs[key]):
+            return True
+    return False
+
+def _values_equal(val1, val2):
+    ''' Test if values are set and equal, or not set (cannot compare value with None) '''
+    if val1 is not None and val2 is not None: # both set
+        return val1 == val2
+    if val1 is None and val2 is None: # both None
+        return True
+    return False # one set and other is None