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

vidavis/__version__.py

@@ -1 +1 @@
-__version__ = '0.0.12'
+__version__ = '0.0.13'

vidavis/apps/_ms_raster.py

@@ -12,13 +12,14 @@ import panel as pn
 
 from vidavis.bokeh._palette import available_palettes
 from vidavis.data.measurement_set.processing_set._ps_coords import set_index_coordinates
-from vidavis.plot.ms_plot._time_ticks import get_time_formatter
-from vidavis.plot.ms_plot._locate_points import locate_point, locate_box
+from vidavis.plot.ms_plot._check_raster_inputs import check_inputs
+from vidavis.plot.ms_plot._locate_points import cursor_changed, points_changed, box_changed, locate_point, locate_box
 from vidavis.plot.ms_plot._ms_plot import MsPlot
 from vidavis.plot.ms_plot._ms_plot_constants import VIS_AXIS_OPTIONS, SPECTRUM_AXIS_OPTIONS, PS_SELECTION_OPTIONS, MS_SELECTION_OPTIONS
+from vidavis.plot.ms_plot._plot_inputs import inputs_changed
 from vidavis.plot.ms_plot._raster_plot_gui import create_raster_gui
-from vidavis.plot.ms_plot._raster_plot_inputs import check_inputs
 from vidavis.plot.ms_plot._raster_plot import RasterPlot
+from vidavis.plot.ms_plot._time_ticks import get_time_formatter
 
 class MsRaster(MsPlot):
     '''
@@ -44,21 +45,13 @@ class MsRaster(MsPlot):
     def __init__(self, ms=None, log_level="info", log_to_file=True, show_gui=False):
         super().__init__(ms, log_level, log_to_file, show_gui, "MsRaster")
         self._raster_plot = RasterPlot()
-        self._plot_data = None
 
         # Calculations for color limits
         self._spw_stats = {}
         self._spw_color_limits = {}
 
         if show_gui:
-            # For checking if plot inputs or cursor position changed and new plot or cursor location info is needed.
-            self._last_plot_inputs = None
-            self._last_style_inputs = None
-            self._last_cursor = None
-            self._last_box = None
-
-            # Return plot for gui DynamicMap:
-            # Empty plot when ms not set or plot fails
+            # Return plot for gui DynamicMap: empty plot when ms not set or plot fails
             self._empty_plot = self._create_empty_plot()
 
             # Set default style and plot inputs to use when launching gui
@@ -66,7 +59,7 @@ class MsRaster(MsPlot):
             self.plot()
             self._launch_gui()
 
-            # Set filename TextInput to input ms, which triggers default plot
+            # Set filename TextInput widget to input ms, which triggers default plot
             if 'ms' in self._ms_info and self._ms_info['ms']:
                 self._set_filename([self._ms_info['ms']]) # function expects list from FileBrowser widget
 
@@ -97,10 +90,8 @@ class MsRaster(MsPlot):
             string_exact_match (bool): whether to require exact matches for string and string list columns (default True) or partial matches (False).
             query (str): a Pandas query string to apply additional filtering.
             **kwargs (dict): keyword arguments representing summary column names and values.
-        See summary(data_group) and data_groups() for selection options. Use keyword 'data_group_name' for data group selection.
-        Summary column names include 'name', 'intents', 'shape', 'polarization', 'scan_name', 'spw_name',
-          'field_name', 'source_name', 'field_coords', 'start_frequency', 'end_frequency'.
-        The selection is applied to the data within the MeasurementSets where applicable (polarization, scan_name, field_name)
+        See data_groups() and summary(data_group) and for selection keyword options. Use keyword 'data_group_name' for data group selection.
+        The selection is also applied to the data within the MeasurementSets where keyword is a coordinate (polarization, scan_name, field_name) and
           string_exact_match=True, else the entire MS is selected.
         Selections are cumulative until clear_selection() is called.
         Raises exception with message if selection fails.
@@ -156,8 +147,8 @@ class MsRaster(MsPlot):
              iter_axis=None, iter_range=None, subplots=None, color_mode=None, color_range=None, title=None, clear_plots=True):
         '''
         Create a raster plot of vis_axis data.
-        Plot axes include data dimensions (time, baseline/antenna, frequency, polarization).
-        The first spectral window (by id) and dimensions not set as plot axes (first value) will be automatically selected if no user selection has been made, unless aggregated.
+        Plot axes include data dimensions (time, baseline/antenna_name, frequency, polarization).
+        The first spectral window by time and dimensions not set as plot axes will be automatically selected by first value if no user selection has been made, unless aggregated.
 
         Args:
             x_axis (str): Plot x-axis. Default 'baseline' ('antenna_name' for spectrum data).
@@ -253,14 +244,20 @@ class MsRaster(MsPlot):
         for key, val in plot_inputs.items():
             self._plot_inputs[key] = val
 
-    def _do_plot(self, plot_inputs):
+    def _do_plot(self, plot_inputs, is_gui_plot=False):
         ''' Create plot using plot inputs '''
         if not self._plot_init:
             self._init_plot(plot_inputs)
 
         # Select vis_axis data to plot and update selection; returns xarray Dataset
         raster_data = self._data.get_raster_data(plot_inputs)
-        self._plot_data = raster_data
+
+        # Save plot data for plot location callbacks unless layout (location not supported)
+        if not self._is_layout():
+            if is_gui_plot:
+                self._gui_plot_data = set_index_coordinates(raster_data, (self._plot_inputs['x_axis'], self._plot_inputs['y_axis']))
+            else:
+                self._plot_data = set_index_coordinates(raster_data, (self._plot_inputs['x_axis'], self._plot_inputs['y_axis']))
 
         # Add params needed for plot: auto color range and ms name
         self._set_auto_color_range(plot_inputs) # set calculated limits if auto mode
@@ -301,10 +298,11 @@ class MsRaster(MsPlot):
         num_subplots = np.prod(subplots) if subplots else 1
         num_iter_plots = min(num_iter_plots, num_subplots) if num_subplots > 1 else num_iter_plots
         end_idx = start_idx + num_iter_plots
+        self._plot_inputs['iter_range'] = (start_idx, end_idx)
 
-        # Set each iter value in ms_selection
-        if 'ms_selection' not in plot_inputs:
-            plot_inputs['ms_selection'] = {}
+        # Set each iter value in selection
+        if 'selection' not in plot_inputs:
+            plot_inputs['selection'] = {}
 
         for i in range(start_idx, end_idx):
             # Select iteration value and make plot
@@ -347,6 +345,22 @@ class MsRaster(MsPlot):
         self._logger.info("Maximum dimensions for selected spw: %s", self._data.get_max_data_dims())
         self._plot_init = True
 
+    def _is_layout(self):
+        ''' Determine if plot is a layout using plot inputs '''
+        # Check if subplots is a layout
+        if self._plot_inputs['subplots'] is None or self._plot_inputs['subplots'] == (1, 1):
+            return False
+
+        # Check if iteration set and iter_range more than one plot
+        iter_length = 0
+        if self._plot_inputs['iter_axis'] is not None:
+            iter_range = self._plot_inputs['iter_range']
+            iter_range = (0, 0) if iter_range is None else iter_range
+            iter_length = len(range(iter_range[0], iter_range[1] + 1))
+
+        # Also check if previous plot(s) not cleared
+        return iter_length > 1 or len(self._plots) > 0
+
     def _set_auto_color_range(self, plot_inputs):
         ''' Calculate stats for color limits for non-gui amplitude plots. '''
         color_mode = plot_inputs['color_mode']
@@ -438,13 +452,14 @@ class MsRaster(MsPlot):
     ### Main callback to create plot if inputs changed
     ###
 # pylint: disable=too-many-arguments, too-many-positional-arguments
-    def _update_plot(self, ms, do_plot, x, y, bounds):
+    def _update_plot(self, ms, do_plot, x, y, data, bounds):
         ''' Create plot with inputs from GUI, or update cursor/box location.
             Callbacks:
                 ms (first plot) - return plot with default inputs
                 do_plot (Plot button clicked) - return plot with inputs from GUI
-                x, y (cursor position) - update cursor location box
-                bounds (box select) - update location of points in box in tab and log
+                x, y (PointerXY) - update cursor location box
+                data (PointDraw from point_draw tool) - update location of drawn points in tab and log
+                bounds (Bounds from box_select tool) - update location of points in box in tab and log
             This function *must* return plot, even if empty plot or last plot, for DynamicMap.
         '''
         # Remove toast notification and collapse selection accordion
@@ -458,13 +473,18 @@ class MsRaster(MsPlot):
 
         # User changed inputs without clicking Plot button, or callback for cursor/box.
         if not do_plot and not self._first_gui_plot:
-            if self._cursor_changed(x, y):
+            if cursor_changed(x, y, self._last_cursor):
                 # new cursor position - update cursor location box
                 self._update_cursor_location(x, y)
                 self._last_cursor = (x, y)
 
-            if self._box_changed(bounds):
-                # new box_select position - update location for points in box
+            if points_changed(data, self._last_points):
+                # new points position - update selected points location tab
+                self._update_points_location(data)
+                self._last_points = data
+
+            if box_changed(bounds, self._last_box):
+                # new box_select position - update selected box location tab
                 self._update_box_location(bounds)
                 self._last_box = bounds
 
@@ -484,9 +504,9 @@ class MsRaster(MsPlot):
         self.clear_selection()
         gui_plot = None
 
+        # Make plot if first plot or changed plot
         style_inputs = self._raster_plot.get_plot_params()['style']
-        if self._inputs_changed(style_inputs):
-            # First plot or changed plot
+        if inputs_changed(self._plot_inputs, self._last_plot_inputs) or inputs_changed(style_inputs, self._last_style_inputs):
             try:
                 # Check inputs from GUI then plot
                 self._plot_inputs['data_dims'] = self._ms_info['data_dims']
@@ -510,60 +530,25 @@ class MsRaster(MsPlot):
         self._last_style_inputs = style_inputs.copy()
         self._last_plot_inputs['ps_selection'] = self._plot_inputs['ps_selection'].copy()
         self._last_plot_inputs['ms_selection'] = self._plot_inputs['ms_selection'].copy()
+
+        # Save plot for return value if plot update not requested
+        self._last_gui_plot = gui_plot
+
+        # Remove selection not from user
         if self._first_gui_plot and not do_plot:
             self._plot_inputs['ps_selection'].clear()
             self._plot_inputs['ms_selection'].clear()
 
-        # Save plot for return value if plot update not requested
-        self._last_gui_plot = gui_plot
         self._first_gui_plot = False
 
-        # Add plot inputs, change plot button to outline, and stop spinner
-        self._update_plot_inputs()
+        # Add plot inputs to GUI, change plot button to outline, and stop spinner
+        self._show_plot_inputs()
         self._update_plot_status(False)
         self._update_plot_spinner(False)
 
         return gui_plot
 # pylint: enable=too-many-arguments, too-many-positional-arguments
 
-    def _cursor_changed(self, x, y):
-        ''' Check whether cursor position changed '''
-        if not x and not y:
-            return False # not cursor callback
-        if self._last_cursor and self._last_cursor == (x, y):
-            return False # same cursor
-        return True # new cursor or cursor changed
-
-    def _box_changed(self, bounds):
-        ''' Check whether box position changed '''
-        if not bounds:
-            return False # no data, not box select callback
-        if self._last_box and self._last_box == bounds:
-            return False # same box
-        return True # new box or box changed
-
-    def _inputs_changed(self, style_inputs):
-        ''' Check if inputs changed and need new plot '''
-        if not self._last_plot_inputs:
-            return True
-
-        for key, val in self._plot_inputs.items():
-            if not self._values_equal(val, self._last_plot_inputs[key]):
-                return True
-
-        for key, val in style_inputs.items():
-            if not self._values_equal(val, self._last_style_inputs[key]):
-                return True
-        return False
-
-    def _values_equal(self, 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
-
     def _do_gui_selection(self):
         ''' Apply selections selected in GUI '''
         if self._plot_inputs['ps_selection']:
@@ -594,7 +579,7 @@ class MsRaster(MsPlot):
                     return layout_plot
 
                 # Make single Overlay raster plot for DynamicMap
-                plot = self._do_plot(self._plot_inputs)
+                plot = self._do_plot(self._plot_inputs, True)
                 plot_params = self._raster_plot.get_plot_params()
 
                 # Update color limits in gui with data range
@@ -606,7 +591,11 @@ class MsRaster(MsPlot):
 
                 self._logger.info("Plot update complete")
                 return plot.opts(
-                    hv.opts.QuadMesh(tools=['hover', 'box_select'])
+                    hv.opts.QuadMesh(
+                        tools=['hover', 'box_select'],
+                        selection_fill_alpha=0.5, # dim selected areas of plot
+                        nonselection_fill_alpha=1.0, # do not dim unselected areas of plot
+                    )
                 )
             except RuntimeError as e:
                 error = f"Plot failed: {str(e)}"
@@ -631,7 +620,11 @@ class MsRaster(MsPlot):
             )
         )
         return plot.opts(
-            hv.opts.QuadMesh(tools=['hover', 'box_select'])
+            hv.opts.QuadMesh(
+                tools=['hover', 'box_select'],
+                selection_fill_alpha=0.5, # dim selected areas of plot
+                nonselection_fill_alpha=1.0, # do not dim unselected areas of plot
+            )
         )
 
     def _set_plot_colorbar(self, plot, plot_params, plot_type):
@@ -834,15 +827,15 @@ class MsRaster(MsPlot):
             spinner = self._gui_layout[2][2][1]
             spinner.value = plot_clicked
 
-    def _update_plot_status(self, inputs_changed):
-        ''' Change button color when inputs change. '''
+    def _update_plot_status(self, plot_changed):
+        ''' Change button color when plot inputs change. '''
         if self._gui_layout:
             # Set button color
             button = self._gui_layout[2][2][0]
-            button.button_style = 'solid' if inputs_changed else 'outline'
+            button.button_style = 'solid' if plot_changed else 'outline'
 
-    def _update_plot_inputs(self):
-        ''' Show inputs for raster plot in GUI '''
+    def _show_plot_inputs(self):
+        ''' Show inputs for raster plot in GUI tab '''
         if self._plot_params:
             inputs_column = self._gui_layout[0][1]
             inputs_column.clear()
@@ -856,14 +849,10 @@ class MsRaster(MsPlot):
         # Convert plot values to selection values to select plot data
         x_axis = self._plot_inputs['x_axis']
         y_axis = self._plot_inputs['y_axis']
-        plot_data = set_index_coordinates(self._plot_data, (x_axis, y_axis))
         cursor_position = {x_axis: x, y_axis: y}
-        cursor_location = locate_point(plot_data, cursor_position, self._plot_inputs['vis_axis'])
-        self._update_cursor_box(cursor_location)
+        cursor_location = locate_point(self._gui_plot_data, cursor_position, self._plot_inputs['vis_axis'])
 
-    def _update_cursor_box(self, cursor_location):
-        ''' Update cursor location widget box with list of Panel StaticText widgets '''
-        cursor_location_box = self._gui_layout[0][0][1] # row 0 tab 0 row 1 in column
+        cursor_location_box = self._gui_layout[0][0][1] # row[0] tabs[0] column[1]
         cursor_location_box.clear() # pn.WidgetBox
         location_layout = pn.Column(pn.widgets.StaticText(name="Cursor Location"))
         location_row = self._layout_point_location(cursor_location)
@@ -890,29 +879,54 @@ class MsRaster(MsPlot):
         location_row.append(location_col)
         return location_row
 
+    def _update_points_location(self, data):
+        ''' Show data values for points in point_draw in tab and log '''
+        points_locate_column = self._gui_layout[0][2] # row[0] tabs[2]
+        points_locate_column.clear()
+        points = list(zip(data['x'], data['y']))
+
+        if points:
+            self._logger.info("Locate selected points:")
+            x_axis = self._plot_inputs['x_axis']
+            y_axis = self._plot_inputs['y_axis']
+
+            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(self._gui_plot_data, point_position, self._plot_inputs['vis_axis'])
+                # Format location and add to points locate column
+                location_layout = self._layout_point_location(point_location)
+                points_locate_column.append(location_layout)
+                points_locate_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]
+                self._logger.info(", ".join(location_list))
+
     def _update_box_location(self, bounds):
-        ''' Show data values for points in box in box location tab and log '''
-        x_axis = self._plot_inputs['x_axis']
-        y_axis = self._plot_inputs['y_axis']
-        plot_data = set_index_coordinates(self._plot_data, (x_axis, y_axis))
-        box_bounds = {x_axis: (bounds[0], bounds[2]), y_axis: (bounds[1], bounds[3])}
-        npoints, point_locations = locate_box(plot_data, box_bounds, self._plot_inputs['vis_axis'])
-
-        locate_column = self._gui_layout[0][2] # row 0 tab 2
-        locate_column.clear()
-        message = f"Locate {npoints} points"
-        message += " (only first 100 shown):" if npoints > 100 else ":"
-        self._logger.info(message)
-
-        for point in point_locations:
-            # Format and add to locate column
-            location_layout = self._layout_point_location(point)
-            locate_column.append(location_layout)
-            locate_column.append(pn.layout.Divider())
-
-            # Format and add to log
-            location_list = [f"{static_text.name}={static_text.value}" for static_text in point]
-            self._logger.info(", ".join(location_list))
+        ''' Show data values for points in box_select in tab and log '''
+        box_locate_column = self._gui_layout[0][3] # row[0] tabs[3]
+        box_locate_column.clear()
+        if bounds:
+            x_axis = self._plot_inputs['x_axis']
+            y_axis = self._plot_inputs['y_axis']
+            box_bounds = {x_axis: (bounds[0], bounds[2]), y_axis: (bounds[1], bounds[3])}
+            npoints, point_locations = locate_box(self._gui_plot_data, box_bounds, self._plot_inputs['vis_axis'])
+
+            message = f"Locate {npoints} points"
+            message += " (only first 100 shown):" if npoints > 100 else ":"
+            self._logger.info(message)
+            box_locate_column.append(pn.pane.Str(message))
+
+            for point in point_locations:
+                # Format and add to box locate column
+                location_layout = self._layout_point_location(point)
+                box_locate_column.append(location_layout)
+                box_locate_column.append(pn.layout.Divider())
+
+                # Format and add to log
+                location_list = [f"{static_text.name}={static_text.value}" for static_text in point]
+                self._logger.info(", ".join(location_list))
 
     ###
     ### Callbacks for widgets which update plot inputs
@@ -968,9 +982,7 @@ class MsRaster(MsPlot):
         else:
             self._plot_inputs['iter_range'] = None
         self._update_plot_status(True) # Change plot button to solid
-# pylint: enable=too-many-arguments, too-many-positional-arguments
 
-# pylint: disable=too-many-arguments, too-many-positional-arguments, unused-argument
     def _set_ps_selection(self, query, name, intents, scan_name, spw_name, field_name, source_name, line_name):
         ''' Select ProcessingSet from gui using summary columns '''
         inputs = locals()

vidavis/plot/ms_plot/{_raster_plot_inputs.py → _check_raster_inputs.py}

@@ -5,7 +5,7 @@ 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 input values. '''
+    ''' Check plot input types, and axis (plot, agg, iter) input values. '''
     _set_baseline_antenna_axis(inputs)
     _check_axis_inputs(inputs)
     _check_agg_inputs(inputs)

vidavis/plot/ms_plot/_locate_points.py

@@ -10,6 +10,32 @@ import panel as pn
 
 from vidavis.plot.ms_plot._ms_plot_constants import TIME_FORMAT
 
+def cursor_changed(x, y, last_cursor):
+    ''' Check whether cursor position changed '''
+    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 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 locate_point(xds, position, vis_axis):
     '''
         Get cursor location as values of coordinates and data vars.
@@ -47,7 +73,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()
@@ -81,9 +107,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 +138,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) '''

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
@@ -50,6 +50,19 @@ class MsPlot:
             pn.config.notifications = True
             self._toast = None # for destroy() with new plot or new notification
 
+            # Initialize gui panel for callbacks
+            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
+            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
@@ -59,11 +72,9 @@ class MsPlot:
         self._plots_locked = False
         self._plots = []
 
-        # Initialize gui
-        if show_gui:
-            self._gui_layout = None
-            self._first_gui_plot = True
-            self._last_gui_plot = None
+        # Initialize show() panel for callbacks
+        self._show_layout = None
+        self._plot_data = None
 
         # Set data (if ms)
         self._data = None
@@ -159,10 +170,10 @@ class MsPlot:
             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)
+            self._show_layout = pn.Tabs(('Plot', bokeh_fig), ('Plot Inputs', column))
         else:
-            show(bokeh_fig)
+            self._show_layout = pn.pane.Bokeh(bokeh_fig)
+        self._show_layout.show(title=self._app_name, threaded=True)
 
     def save(self, filename='ms_plot.png', fmt='auto', width=900, height=600):
         '''

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

vidavis/plot/ms_plot/_raster_plot_gui.py

@@ -9,9 +9,42 @@ from vidavis.plot.ms_plot._ms_plot_selectors import (file_selector, title_select
 
 def create_raster_gui(callbacks, data_dims, x_axis, y_axis):
     ''' Use Holoviz Panel to create a dashboard for plot inputs and raster plot display. '''
-    # ------------------
-    # PLOT INPUTS COLUMN
-    # ------------------
+    # Accordion of widgets for plot inputs
+    selectors = get_plot_input_selectors(callbacks, data_dims, x_axis, y_axis)
+
+    # Plot button and spinner while plotting
+    init_plot = plot_starter(callbacks['plot_updating'])
+
+    # Dynamic map for plot, with callback when inputs change or location needed
+    dmap, points = get_plot_dmap(callbacks, selectors, init_plot)
+
+    return pn.Row(
+        pn.Tabs(             # Row [0]
+            ('Plot',                                 # Tabs[0]
+                pn.Column(
+                    dmap * points,  # [0] plot with hv.Points overlay for point_draw
+                    pn.WidgetBox(), # [1] cursor location
+                )
+            ),
+            ('Plot Inputs', pn.Column()),            # Tabs[1]
+            ('Locate Selected Points', pn.Column()), # Tabs[2]
+            ('Locate Selected Box', pn.Column()),    # Tabs[3]
+            sizing_mode='stretch_width',
+        ),
+        pn.Spacer(width=10), # Row [1]
+        pn.Column(  # Row [2]
+            pn.Spacer(height=25), # Column[0]
+            selectors,            # Column[1]
+            init_plot,            # Column[2]
+            width_policy='min',
+            width=400,
+            sizing_mode='stretch_height',
+        ),
+        sizing_mode='stretch_height',
+    )
+
+def get_plot_input_selectors(callbacks, data_dims, x_axis, y_axis):
+    ''' Create accordion of widgets for plot inputs selection '''
     # Select MS
     file_selectors = file_selector('Path to MeasurementSet (ms or zarr) for plot', '~' , callbacks['filename'])
 
@@ -47,50 +80,26 @@ def create_raster_gui(callbacks, data_dims, x_axis, y_axis):
         ("Plot title", title_input),             # [6]
     )
     selectors.toggle = True
+    return selectors
 
-    # Plot button and spinner while plotting
-    init_plot = plot_starter(callbacks['plot_updating'])
-
-    # ----------------------------------------
-    # PLOT WITH CURSOR POSITION AND BOX SELECT
-    # ----------------------------------------
-    # Connect plot to filename and plot button; add streams for cursor position and selected box
-    # 'update_plot' callback must have parameters (ms, do_plot, x, y, data)
+def get_plot_dmap(callbacks, selectors, init_plot):
+    ''' Dynamic map for updating plot from callback function '''
+    # Connect plot to filename and plot button; add streams for cursor position, drawn points, and selected box
+    # 'update_plot' callback must have parameters (ms, do_plot, x, y, data, bounds)
+    points = hv.Points([]).opts(
+        size=5,
+        fill_color='white'
+    )
     dmap = hv.DynamicMap(
         pn.bind(
             callbacks['update_plot'],
-            ms=file_selectors[0][0],
+            ms=selectors[0][0][0],
             do_plot=init_plot[0],
         ),
         streams=[
-            hv.streams.PointerXY(), # cursor location (x, y)
-            hv.streams.BoundsXY()   # box location (bounds)
+            hv.streams.PointerXY(),              # cursor location (x, y)
+            hv.streams.PointDraw(source=points), # fixed cursor location (data)
+            hv.streams.BoundsXY()                # box location (bounds)
         ]
     )
-
-    # ----------------------------------------------
-    # GUI LAYOUT OF PLOT TABS AND PLOT INPUTS COLUMN
-    # ----------------------------------------------
-    return pn.Row(
-        pn.Tabs(             # Row [0]
-            ('Plot',
-                pn.Column(                # Tabs [0]
-                    dmap,           # [0]
-                    pn.WidgetBox(), # [1] cursor location
-                )
-            ),
-            ('Plot Inputs', pn.Column()),         # Tabs [1]
-            ('Locate Selected Box', pn.Column()), # Tabs [2]
-            sizing_mode='stretch_width',
-        ),
-        pn.Spacer(width=10), # Row [1]
-        pn.Column(  # Row [2]
-            pn.Spacer(height=25), # Column [0]
-            selectors,            # Column [1]
-            init_plot,            # Column [2]
-            width_policy='min',
-            width=400,
-            sizing_mode='stretch_height',
-        ),
-        sizing_mode='stretch_height',
-    )
+    return dmap, points

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

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

{vidavis-0.0.12.dist-info → vidavis-0.0.13.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=lbq9GRGeyIV1a_kyS8nU0XfadMwQbOC7JZj6Zcp2uo8,47260
+vidavis/apps/_ms_raster.py,sha256=bWe7N7lbwNYzPl1n-_Y_qBErDddxVe8jnPRYqOxylSI,48397
 vidavis/bokeh/__init__.py,sha256=gdPPxBCe0enCSjvPFxkgMlhpVnAMFXKcw9GN28tVdXM,95
 vidavis/bokeh/_palette.py,sha256=gzfJHuUgqxd8hJpZe-gQPFTCPq9f5I8uLEkHAK5FNDM,2480
 vidavis/data/__init__.py,sha256=-RDRe0PYK6vPlhdRV2Dy1vGbnDGoXWDATmfxaR-gXcE,48
@@ -18,21 +18,22 @@ vidavis/data/measurement_set/processing_set/_ps_stats.py,sha256=4uLImKCANXLUM8jO
 vidavis/data/measurement_set/processing_set/_xds_data.py,sha256=qLO2VkLINkSAQ7CGRFmpWQYpHrP4XoJJkwA4pp9DO8M,5253
 vidavis/plot/__init__.py,sha256=thxe5vAGdpEiqoKPHLJoWUqKMVrUVx0ajpsGf5pVP98,95
 vidavis/plot/ms_plot/__init__.py,sha256=wY0_7gY9M6K1D6tKQsr89L_uSs3seJlD-uicx7dx5Mo,74
-vidavis/plot/ms_plot/_locate_points.py,sha256=TsfklqCB-rab8VKsnSwnFy-hh7JSY7Wp7Lo498ad10M,6161
-vidavis/plot/ms_plot/_ms_plot.py,sha256=AZe4WbW5QCjX5hIir1W4H8Nd69NvxBQUiJhIHPCOTGE,12764
+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/_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=wpVFnnX9jL4G4b9OhCxgGpqrqUq4cvDLy4IIzYRMR18,3738
-vidavis/plot/ms_plot/_raster_plot_inputs.py,sha256=vPjZPDuB26ENxwv4z7dUa_c5TqByXejScY6hqEnLFLU,4768
+vidavis/plot/ms_plot/_raster_plot_gui.py,sha256=Kb0BLmkwtYHCqlVaSipbTTStst8RYggqwf1Wf5v8F4Q,4261
 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=28LaL9J1JRdBfN4Edp_03ZUWOZCUdFtygoKFI5dYdXA,22
-vidavis-0.0.12.dist-info/WHEEL,sha256=B19PGBCYhWaz2p_UjAoRVh767nYQfk14Sn4TpIZ-nfU,87
-vidavis-0.0.12.dist-info/METADATA,sha256=3ZnkBJhcC1bVNAkVvRIVxRGfvo6_wow4DWPOvFOIqVA,2238
-vidavis-0.0.12.dist-info/licenses/LICENSE,sha256=IMF9i4xIpgCADf0U-V1cuf9HBmqWQd3qtI3FSuyW4zE,26526
-vidavis-0.0.12.dist-info/RECORD,,
+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,,