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

vidavis/apps/_ms_raster.py

@@ -8,17 +8,15 @@ from bokeh.models.formatters import NumeralTickFormatter
 import holoviews as hv
 import numpy as np
 from pandas import to_datetime
-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._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 import RasterPlot
+from vidavis.plot.ms_plot._raster_plot_gui import create_raster_gui
+from vidavis.plot.ms_plot._raster_plot_inputs import RasterPlotInputs
 from vidavis.plot.ms_plot._time_ticks import get_time_formatter
 
 class MsRaster(MsPlot):
@@ -44,6 +42,8 @@ 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._plot_inputs = RasterPlotInputs()
+        self._plot_inputs.set_input('ms', self._ms_info['ms'])
         self._raster_plot = RasterPlot()
 
         # Calculations for color limits
@@ -51,17 +51,21 @@ class MsRaster(MsPlot):
         self._spw_color_limits = {}
 
         if show_gui:
-            # 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
+            # Set default style and plot inputs to use for empty plot and gui
             self.set_style_params()
             self.plot()
+
+            # Initial plot for gui
+            self._create_empty_plot()
+
+            # Create and show gui panel
             self._launch_gui()
 
-            # Set filename TextInput widget to input ms, which triggers default plot
+            # Set filename TextInput widget to input ms
             if 'ms' in self._ms_info and self._ms_info['ms']:
-                self._set_filename([self._ms_info['ms']]) # function expects list from FileBrowser widget
+                self._set_filename(self._ms_info['ms'])
+                self._update_gui_ms_options()
+                self._update_plot(do_plot=True)
 
     def colormaps(self):
         ''' List available colormap (Bokeh palettes). '''
@@ -99,12 +103,10 @@ class MsRaster(MsPlot):
         For explanation and examples, see:
         https://xradio.readthedocs.io/en/latest/measurement_set/schema_and_api/measurement_set_api.html#xradio.measurement_set.ProcessingSetXdt.query
         '''
-        if self._data and self._data.is_valid():
+        if self._ms_data and self._ms_data.is_valid():
             try:
-                self._plot_inputs['selection'] |= kwargs
-                if 'data_group_name' in kwargs:
-                    self._plot_inputs['data_group'] = kwargs['data_group_name']
-                self._data.select_ps(query=query, string_exact_match=string_exact_match, **kwargs)
+                self._plot_inputs.set_selection(kwargs)
+                self._ms_data.select_ps(query=query, string_exact_match=string_exact_match, **kwargs)
             except KeyError as ke:
                 error = "ProcessingSet selection yielded empty ProcessingSet."
                 if not self._show_gui:
@@ -128,12 +130,10 @@ class MsRaster(MsPlot):
         For explanation of parameters and examples, see:
         https://xradio.readthedocs.io/en/latest/measurement_set/schema_and_api/measurement_set_api.html#xradio.measurement_set.MeasurementSetXdt.sel
         '''
-        if self._data and self._data.is_valid():
+        if self._ms_data and self._ms_data.is_valid():
             try:
-                self._plot_inputs['selection'] |= indexers_kwargs
-                self._data.select_ms(indexers=indexers, method=method, tolerance=tolerance, drop=drop, **indexers_kwargs)
-                if 'data_group_name' in indexers_kwargs:
-                    self._plot_inputs['data_group'] |= indexers_kwargs['data_group_name']
+                self._plot_inputs.set_selection(indexers_kwargs)
+                self._ms_data.select_ms(indexers=indexers, method=method, tolerance=tolerance, drop=drop, **indexers_kwargs)
             except KeyError as ke:
                 error = str(ke).strip("\'")
                 if not self._show_gui:
@@ -179,34 +179,37 @@ class MsRaster(MsPlot):
 
         If plot is successful, use show() or save() to view/save the plot.
         '''
-        inputs = locals() # collect arguments into dict (not unused as pylint complains!)
-        if self._plot_inputs['selection']:
-            self._logger.info("Create raster plot with selection: %s", self._plot_inputs['selection'])
+        inputs = locals() # collect arguments into dict
 
         start = time.time()
 
+        # If previous plot was shown, unlink from data streams
+        super().unlink_plot_streams()
+
         # Clear for new plot
         self._reset_plot(clear_plots)
 
         # Get data dimensions if valid MS is set to check input axes
         if 'data_dims' in self._ms_info:
-            inputs['data_dims'] = self._ms_info['data_dims'] if 'data_dims' in self._ms_info else None
+            data_dims = self._ms_info['data_dims'] if 'data_dims' in self._ms_info else None
+            inputs['data_dims'] = data_dims
 
-        # Validate input arguments then set
-        check_inputs(inputs)
-        self._set_plot_inputs(inputs)
+        self._plot_inputs.set_inputs(inputs)
+        selection = self._plot_inputs.get_input('selection')
+        if selection:
+            self._logger.info("Create raster plot with selection: %s", selection)
 
         if not self._show_gui:
             # Cannot plot if no MS
-            if not self._data or not self._data.is_valid():
+            if not self._ms_data or not self._ms_data.is_valid():
                 raise RuntimeError("Cannot plot MS: input MS path is invalid or missing.")
 
             # Create raster plot and add to plot list
             try:
-                if self._plot_inputs['iter_axis']:
-                    self._do_iter_plot(self._plot_inputs)
+                if self._plot_inputs.get_input('iter_axis'):
+                    self._do_iter_plot()
                 else:
-                    plot = self._do_plot(self._plot_inputs)
+                    plot = self._do_plot()
                     self._plots.append(plot)
             except RuntimeError as e:
                 error = f"Plot failed: {str(e)}"
@@ -239,160 +242,155 @@ class MsRaster(MsPlot):
             filename = f"{self._ms_info['basename']}_raster.png"
         super().save(filename, fmt, width, height)
 
-    def _set_plot_inputs(self, plot_inputs):
-        ''' Set inputs from latest plot() call '''
-        for key, val in plot_inputs.items():
-            self._plot_inputs[key] = val
-
-    def _do_plot(self, plot_inputs, is_gui_plot=False):
+    def _do_plot(self, is_gui_plot=False):
         ''' Create plot using plot inputs '''
         if not self._plot_init:
-            self._init_plot(plot_inputs)
+            self._init_plot()
 
         # Select vis_axis data to plot and update selection; returns xarray Dataset
-        raster_data = self._data.get_raster_data(plot_inputs)
+        raster_data = self._ms_data.get_raster_data(self._plot_inputs.get_inputs())
 
         # Save plot data for plot location callbacks unless layout (location not supported)
-        if not self._is_layout():
+        if not self._plot_inputs.is_layout():
+            x_axis = self._plot_inputs.get_input('x_axis')
+            y_axis = self._plot_inputs.get_input('y_axis')
             if is_gui_plot:
-                self._gui_plot_data = set_index_coordinates(raster_data, (self._plot_inputs['x_axis'], self._plot_inputs['y_axis']))
+                self._gui_plot_data = set_index_coordinates(raster_data, (x_axis, y_axis))
             else:
-                self._plot_data = set_index_coordinates(raster_data, (self._plot_inputs['x_axis'], self._plot_inputs['y_axis']))
+                self._plot_data = set_index_coordinates(raster_data, (x_axis, 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
+        self._set_auto_color_range() # set calculated limits if auto mode
         ms_name = self._ms_info['basename'] # for title
+        plot_inputs = self._plot_inputs.get_inputs()
         self._raster_plot.set_plot_params(raster_data, plot_inputs, ms_name)
 
         # Show plot inputs in log
         super()._set_plot_params(plot_inputs | self._raster_plot.get_plot_params()['style'])
-        self._logger.info("MsRaster plot parameters: %s", ", ".join(self._plot_params))
+        plot_params = [f"{key}={value}" for key, value in self._plot_params.items()]
+        self._logger.info("MsRaster plot inputs: %s", ", ".join(plot_params))
 
         # Make plot. Add data min/max if GUI is shown to update color limits range.
         return self._raster_plot.raster_plot(raster_data, self._logger, self._show_gui)
 
-    def _do_iter_plot(self, plot_inputs):
+    def _do_iter_plot(self):
         ''' Create one plot per iteration value in iter_range which fits into subplots '''
         # Default (0, 0) (first iteration only). Use (0, -1) for all iterations.
         # If subplots is a grid, end iteration index is limited by the grid size.
         # If subplots is a single plot, all iteration plots in the range can be saved using export_range in save().
-        iter_axis = plot_inputs['iter_axis']
-        iter_range = plot_inputs['iter_range']
-        subplots = plot_inputs['subplots']
-
-        iter_range = (0, 0) if iter_range is None else iter_range
-        start_idx, end_idx = iter_range
+        iter_axis = self._plot_inputs.get_input('iter_axis')
+        iter_range = self._plot_inputs.get_input('iter_range')
+        subplots = self._plot_inputs.get_input('subplots')
 
         # Init plot before getting iter values
-        self._init_plot(plot_inputs)
-
-        iter_values = self._data.get_dimension_values(iter_axis)
+        self._init_plot()
+        iter_values = self._ms_data.get_dimension_values(iter_axis)
         n_iter = len(iter_values)
 
+        iter_range = (0, 0) if iter_range is None else iter_range
+        start_idx, end_idx = iter_range
+        auto_range = end_idx == -1
+
         if start_idx >= n_iter:
             raise IndexError(f"iter_range start {start_idx} is greater than number of iterations {n_iter}")
         end_idx = n_iter if (end_idx == -1 or end_idx >= n_iter) else end_idx + 1
         num_iter_plots = end_idx - start_idx
 
-        # Plot the minimum of iter range or subplots number of plots
+        # Plot the minimum of iter range or subplots number of plots.
+        # If subplots is single plot, plot all for save()
         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 selection
-        if 'selection' not in plot_inputs:
-            plot_inputs['selection'] = {}
+        if auto_range:
+            # For listing plot inputs
+            start_idx = start_idx.item() if isinstance(start_idx, np.int64) else start_idx
+            end_idx = end_idx.item() if isinstance(end_idx, np.int64) else end_idx
+            self._plot_inputs.set_input('auto_iter_range', (start_idx, end_idx - 1))
 
         for i in range(start_idx, end_idx):
             # Select iteration value and make plot
             value = iter_values[i]
             self._logger.info("Plot %s iteration index %s value %s", iter_axis, i, value)
-            plot_inputs['selection'][iter_axis] = value
+            self._plot_inputs.set_selection({iter_axis: value})
             try:
-                plot = self._do_plot(plot_inputs)
+                plot = self._do_plot()
                 self._plots.append(plot)
             except RuntimeError as e:
                 self._logger.info("Iteration plot for value %s failed: %s", str(value), str(e))
                 continue
 
-    def _init_plot(self, plot_inputs):
+    def _init_plot(self):
         ''' Apply automatic selection '''
         # Remove previous auto selections
         for key in ['dim_selection', 'auto_spw']:
-            try:
-                del self._plot_inputs[key]
-            except KeyError:
-                pass
+            self._plot_inputs.remove_input(key)
 
         # Automatically select data group and spw name if not user-selected
         auto_selection = {}
-        if 'data_group' not in plot_inputs:
+        if not self._plot_inputs.get_input('data_group'):
             auto_selection['data_group_name'] = 'base'
-            plot_inputs['data_group'] = 'base'
-        if 'selection' not in plot_inputs or 'spw_name' not in plot_inputs['selection']:
-            first_spw = self._data.get_first_spw(plot_inputs['data_group'])
+            self._plot_inputs.set_input('data_group', 'base')
+
+        data_group = self._plot_inputs.get_input('data_group')
+        spw_selection = self._plot_inputs.get_selection('spw_name')
+        if not spw_selection:
+            first_spw = self._ms_data.get_first_spw(data_group)
             auto_selection['spw_name'] = first_spw
-            plot_inputs['auto_spw'] = first_spw # do not add to user selection
+            self._plot_inputs.set_input('auto_spw', first_spw) # keep separate from user selection
 
         if auto_selection:
             # Do selection and save to plot inputs
             self._logger.info("Automatic selection of data group and/or spw: %s", auto_selection)
-            self._data.select_ps(query=None, string_exact_match=True, **auto_selection)
+            self._ms_data.select_ps(query=None, string_exact_match=True, **auto_selection)
 
         # Print data info for spw selection
-        self._logger.info("Plotting %s msv4 datasets.", self._data.get_num_ms())
-        self._logger.info("Maximum dimensions for selected spw: %s", self._data.get_max_data_dims())
+        self._logger.info("Plotting %s msv4 datasets.", self._ms_data.get_num_ms())
+        self._logger.info("Maximum dimensions for selected spw: %s", self._ms_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):
+    def _set_auto_color_range(self):
         ''' Calculate stats for color limits for non-gui amplitude plots. '''
-        color_mode = plot_inputs['color_mode']
-        color_limits = None
+        color_mode = self._plot_inputs.get_input('color_mode')
+        auto_color_limits = None
 
         if color_mode == 'auto':
-            if plot_inputs['vis_axis']=='amp' and not plot_inputs['aggregator']:
+            if self._plot_inputs.get_input('vis_axis') == 'amp' and not self._plot_inputs.get_input('aggregator'):
                 # For amplitude, limit colorbar range using stored per-spw ms stats
-                spw_name = self._plot_inputs['selection']['spw_name'] if ('selection' in plot_inputs and 'spw_name' in plot_inputs['selection']) else self._plot_inputs['auto_spw']
+                spw_name = self._plot_inputs.get_selection('spw_name')
+                if not spw_name:
+                    spw_name = self._plot_inputs.get_input('auto_spw')
+
                 if spw_name in self._spw_color_limits:
-                    color_limits = self._spw_color_limits[spw_name]
+                    auto_color_limits = self._spw_color_limits[spw_name]
                 else:
                     # Select spw name and data group only, no dimensions
-                    data_group = self._plot_inputs['data_group']
+                    data_group = self._plot_inputs.get_input('data_group')
                     spw_data_selection = {'spw_name': spw_name, 'data_group_name': data_group}
-                    color_limits = self._calc_amp_color_limits(spw_data_selection)
-                    self._spw_color_limits[spw_name] = color_limits
-        plot_inputs['auto_color_range'] = color_limits
-
-        if color_limits:
-            self._logger.info("Setting amplitude color range: (%.4f, %.4f).", color_limits[0], color_limits[1])
+                    auto_color_limits = self._calc_amp_color_limits(spw_data_selection)
+
+                    if auto_color_limits:
+                        # Convert to float for listing plot inputs
+                        start, end = auto_color_limits
+                        start = start.item() if isinstance(start, np.float64) else start
+                        end = end.item() if isinstance(end, np.float64) else end
+                        auto_color_limits = (start, end)
+                    self._spw_color_limits[spw_name] = auto_color_limits
+        self._plot_inputs.set_input('auto_color_range', auto_color_limits)
+
+        if auto_color_limits:
+            self._logger.info("Setting amplitude color range: (%.4f, %.4f).", auto_color_limits[0], auto_color_limits[1])
         elif color_mode is None:
             self._logger.info("Autoscale color range")
         else:
-            self._logger.info("Using manual color range: %s", plot_inputs['color_range'])
+            self._logger.info("Using manual color range: %s", self._plot_inputs.get_input('color_range'))
 
     def _calc_amp_color_limits(self, selection):
         # Calculate colorbar limits from amplitude stats for unflagged data in selected spw
         self._logger.info("Calculating stats for colorbar limits.")
         start = time.time()
 
-        ms_stats = self._data.get_vis_stats(selection, 'amp')
+        ms_stats = self._ms_data.get_vis_stats(selection, 'amp')
         self._spw_stats['spw_name'] = ms_stats
         if not ms_stats:
             return None # autoscale
@@ -417,7 +415,7 @@ class MsRaster(MsPlot):
         if clear_plots:
             super().clear_plots()
 
-        # Clear params set for last plot
+        # Clear params for last plot
         self._raster_plot.reset_plot_params()
 
         # Unitialize plot to redo auto selections if needed
@@ -429,7 +427,8 @@ class MsRaster(MsPlot):
     def _launch_gui(self):
         ''' Use Holoviz Panel to create and show a dashboard for plot inputs. '''
         callbacks = {
-            'filename': self._set_filename,
+            'set_filename': self._set_filename,
+            'select_filename': self._select_filename,
             'style': self._set_style_params,
             'color': self._set_color_range,
             'axes': self._set_axes,
@@ -439,164 +438,125 @@ class MsRaster(MsPlot):
             'iter_values': self._set_iter_values,
             'iteration': self._set_iteration,
             'title': self._set_title,
-            'plot_updating': self._update_plot_spinner,
             'update_plot': self._update_plot,
         }
+
         data_dims = self._ms_info['data_dims'] if 'data_dims' in self._ms_info else None
-        x_axis = self._plot_inputs['x_axis']
-        y_axis = self._plot_inputs['y_axis']
-        self._gui_layout = create_raster_gui(callbacks, data_dims, x_axis, y_axis)
-        self._gui_layout.show(title=self._app_name, threaded=True)
+        plot_info = {
+            'ms': self._ms_info['ms'],
+            'data_dims': data_dims,
+            'x_axis': self._plot_inputs.get_input('x_axis'),
+            'y_axis': self._plot_inputs.get_input('y_axis'),
+        }
+
+        self._gui_panel = create_raster_gui(callbacks, plot_info, self._empty_plot)
+        self._gui_panel.show(title=self._app_name, threaded=True)
 
     ###
     ### 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, data, bounds):
+    def _update_plot(self, do_plot):
         ''' 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 (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.
         '''
+        if not do_plot or not self._gui_panel:
+            return
+
         # Remove toast notification and collapse selection accordion
         if self._toast:
             self._toast.destroy()
         self._get_selector("selectors").active = []
-
-        if not ms:
-            # GUI launched with no MS, nothing to plot
-            return self._empty_plot
-
-        # User changed inputs without clicking Plot button, or callback for cursor/box.
-        if not do_plot and not self._first_gui_plot:
-            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 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
-
-            # Not ready to update plot yet, return last plot.
-            return self._last_gui_plot
-
-        # First plot for input ms, or user clicked Plot button for new inputs
-        if (self._set_ms(ms) or self._first_gui_plot) and self._data and self._data.is_valid():
-            # New MS set and is valid
-            self._update_gui_axis_options()
-
-        # Add ms path to detect change and make new plot
-        self._plot_inputs['ms'] = ms
-
-        # Do new plot or resend last plot
-        self._reset_plot()
-        self.clear_selection()
         gui_plot = None
 
-        # Make plot if first plot or changed plot
-        style_inputs = self._raster_plot.get_plot_params()['style']
-        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']
-                check_inputs(self._plot_inputs)
-                if 'ps_selection' in self._plot_inputs or 'ms_selection' in self._plot_inputs:
-                    self._do_gui_selection()
-                gui_plot = self._do_gui_plot()
-            except (ValueError, TypeError, KeyError, RuntimeError) as e:
-                # Clear plot, inputs invalid
-                self._notify(str(e), 'error', 0)
-                gui_plot = self._empty_plot
-        else:
-            # Subparam values changed but not applied to plot
-            gui_plot = self._last_gui_plot
-
-        # Update plot inputs for gui
-        self._set_plot_params(self._plot_inputs | style_inputs)
-
-        # Save inputs to see if changed next time
-        self._last_plot_inputs = self._plot_inputs.copy()
-        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()
+        if self._plot_inputs.get_input('ms'):
+            # Start spinner
+            self._update_plot_status(True)
+            self._update_plot_spinner(True)
+
+            # Clear last plot
+            self._reset_plot()
+            self.clear_selection()
+            if 'ps_selection' in self._gui_selection or 'ms_selection' in self._gui_selection:
+                self._do_gui_selection()
+
+            # Make plot if first plot or changed plot
+            style_inputs = self._raster_plot.get_plot_params()['style']
+            plot_inputs = self._plot_inputs.get_inputs()
+            if inputs_changed(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.set_input('data_dims', self._ms_info['data_dims'])
+                    self._plot_inputs.check_inputs()
+                    gui_plot = self._do_gui_plot()
+                    self._last_gui_plot = gui_plot # save plot for locate callback
+                    self._logger.info("Plot update complete")
 
-        # Save plot for return value if plot update not requested
-        self._last_gui_plot = gui_plot
+                    # Put plot with dmap for locate streams in gui panel
+                    dmap = self._get_locate_dmap(self._locate_gui_points)
+                    self._gui_panel[0][0][0].object = gui_plot * dmap
+                except (ValueError, TypeError, KeyError, RuntimeError) as e:
+                    # Clear plot, inputs invalid
+                    self._notify(str(e), 'error', 0)
 
-        # 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()
+        # Update plot inputs for gui tab
+        self._set_plot_params(plot_inputs | style_inputs)
+        self._show_plot_inputs()
 
-        self._first_gui_plot = False
+        # Save inputs to check if changed next time
+        self._last_plot_inputs = plot_inputs.copy()
+        self._last_style_inputs = style_inputs.copy()
 
         # 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 _locate_gui_points(self, x, y, data, bounds):
+        ''' Callback for locate streams '''
+        if self._gui_plot_data:
+            super()._locate_cursor(x, y, self._gui_plot_data, self._gui_panel[0])
+            super()._locate_points(data, self._gui_plot_data, self._gui_panel[0])
+            super()._locate_box(bounds, self._gui_plot_data, self._gui_panel[0])
+        return self._last_gui_plot
+
     def _do_gui_selection(self):
         ''' Apply selections selected in GUI '''
-        if self._plot_inputs['ps_selection']:
-            self.select_ps(**self._plot_inputs['ps_selection'])
-        if self._plot_inputs['ms_selection']:
-            self.select_ms(**self._plot_inputs['ms_selection'])
+        if self._gui_selection['ps_selection']:
+            self.select_ps(**self._gui_selection['ps_selection'])
+        if self._gui_selection['ms_selection']:
+            self.select_ms(**self._gui_selection['ms_selection'], drop=True)
 
     ###
     ### Create plot for DynamicMap
     ###
     def _do_gui_plot(self):
         ''' Create plot based on gui plot inputs '''
-        if self._data and self._data.is_valid():
+        if self._ms_data and self._ms_data.is_valid():
             try:
-                if self._plot_inputs['iter_axis']:
+                if self._plot_inputs.get_input('iter_axis'):
                     # Make iter plot (possibly with subplots layout)
-                    self._do_iter_plot(self._plot_inputs)
-                    subplots = self._plot_inputs['subplots']
-                    layout_plot, is_layout = super()._layout_plots(subplots)
-
-                    if is_layout:
+                    self._do_iter_plot()
+                    subplots = self._plot_inputs.get_input('subplots')
+                    layout_plot = super()._layout_plots(subplots)
+                    if self._plot_inputs.is_layout():
                         # Cannot show Layout in DynamicMap, show in new tab
                         super().show()
-                        self._logger.info("Plot update complete")
-                        return self._last_gui_plot
+                        return self._last_plot
                     # Overlay raster plot for DynamicMap
-                    self._logger.info("Plot update complete")
                     return layout_plot
 
                 # Make single Overlay raster plot for DynamicMap
-                plot = self._do_plot(self._plot_inputs, True)
-                plot_params = self._raster_plot.get_plot_params()
+                gui_plot = self._do_plot(True)
 
                 # Update color limits in gui with data range
+                plot_params = self._raster_plot.get_plot_params()
                 self._update_color_range(plot_params)
 
-                # Update colorbar labels and limits
-                plot.QuadMesh.I = self._set_plot_colorbar(plot.QuadMesh.I, plot_params, "flagged")
-                plot.QuadMesh.II = self._set_plot_colorbar(plot.QuadMesh.II, plot_params, "unflagged")
-
-                self._logger.info("Plot update complete")
-                return plot.opts(
-                    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
-                    )
-                )
+                return gui_plot
             except RuntimeError as e:
                 error = f"Plot failed: {str(e)}"
                 super()._notify(error, "error", 0)
@@ -607,7 +567,7 @@ class MsRaster(MsPlot):
     def _create_empty_plot(self):
         ''' Create empty Overlay plot for DynamicMap with colormap params and required tools enabled '''
         plot_params = self._raster_plot.get_plot_params()
-        plot = hv.Overlay(
+        self._empty_plot = hv.Overlay(
             hv.QuadMesh([]).opts(
                 colorbar=plot_params['style']['show_flagged_colorbar'],
                 cmap=plot_params['style']['flagged_cmap'],
@@ -619,51 +579,14 @@ class MsRaster(MsPlot):
                 responsive=True,
             )
         )
-        return plot.opts(
-            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):
-        ''' Update plot colorbar labels and limits
-                plot_type is "unflagged" or "flagged"
-        '''
-        # Update colorbar labels if shown, else hide
-        colorbar_key = plot_type + '_colorbar'
-        if plot_params['plot'][colorbar_key]:
-            c_label = plot_params['plot']['axis_labels']['c']['label']
-            cbar_title = "Flagged " + c_label if plot_type == "flagged" else c_label
-
-            plot = plot.opts(
-                colorbar=True,
-                backend_opts={
-                    "colorbar.title": cbar_title,
-                }
-            )
-        else:
-            plot = plot.opts(
-                colorbar=False,
-            )
-
-        # Update plot color limits
-        color_limits = plot_params['plot']['color_limits']
-        if color_limits:
-            plot = plot.opts(
-                clim=color_limits,
-            )
-
-        return plot
 
     def _update_color_range(self, plot_params):
         ''' Set the start/end range on the colorbar to min/max of plot data '''
-        if self._gui_layout and 'data' in plot_params and 'data_range' in plot_params['data']:
+        if self._gui_panel and 'data' in plot_params and 'data_range' in plot_params['data']:
             # Update range slider start and end to data min and max
             data_range = plot_params['data']['data_range']
             style_selectors = self._get_selector('style')
-            range_slider = style_selectors[3][1]
+            range_slider = style_selectors[2][1]
             range_slider.start = data_range[0]
             range_slider.end = data_range[1]
 
@@ -672,13 +595,17 @@ class MsRaster(MsPlot):
     ###
     def _get_selector(self, name):
         ''' Return selector group for name, for setting options '''
-        selectors = self._gui_layout[2][1]
-        selectors_index = {'file': 0, 'style': 1, 'sel': 2, 'axes': 3, 'agg': 4, 'iter': 5, 'title': 6}
+        if not self._gui_panel:
+            return None
+
+        selectors = self._gui_panel[2][1]
         if name == "selectors":
             return selectors
+
+        selectors_index = {'file': 0, 'style': 1, 'sel': 2, 'axes': 3, 'agg': 4, 'iter': 5, 'title': 6}
         return selectors[selectors_index[name]]
 
-    def _update_gui_axis_options(self):
+    def _update_gui_ms_options(self):
         ''' Set gui options from ms data '''
         if 'data_dims' in self._ms_info:
             data_dims = self._ms_info['data_dims']
@@ -705,7 +632,7 @@ class MsRaster(MsPlot):
             # Update options for vis_axis selector
             vis_axis_selector = axis_selectors.objects[2]
             vis_axis_value = vis_axis_selector.value
-            if self._data.get_correlated_data('base') == 'SPECTRUM':
+            if self._ms_data.get_correlated_data('base') == 'SPECTRUM':
                 vis_axis_selector.options = SPECTRUM_AXIS_OPTIONS
             else:
                 vis_axis_selector.options = VIS_AXIS_OPTIONS
@@ -731,8 +658,8 @@ class MsRaster(MsPlot):
 
     def _update_ps_selection_options(self, ps_selectors):
         ''' Set ProcessingSet gui options from ms summary '''
-        if self._data and self._data.is_valid():
-            summary = self._data.get_summary()
+        if self._ms_data and self._ms_data.is_valid():
+            summary = self._ms_data.get_summary()
             if summary is None:
                 return
 
@@ -745,11 +672,14 @@ class MsRaster(MsPlot):
                             options.extend(value)
                         else:
                             options.append(value)
-                    selector.options = sorted(list(set(options)))
+                    if options:
+                        selector.options = sorted(list(set(options)))
+                    else:
+                        selector.options = ['']
 
     def _update_ms_selection_options(self, ms_selectors):
         ''' Set MeasurementSet gui options from ms data '''
-        if self._data and self._data.is_valid():
+        if self._ms_data and self._ms_data.is_valid():
             for selector in ms_selectors:
                 selection_key = MS_SELECTION_OPTIONS[selector.name] if selector.name in MS_SELECTION_OPTIONS else None
                 if selection_key:
@@ -761,28 +691,23 @@ class MsRaster(MsPlot):
     ###
     ### Callbacks for widgets which update other widgets
     ###
-    def _set_filename(self, filename):
+    def _select_filename(self, filename):
         ''' Set filename in text box from file selector value (list) '''
-        if filename and self._gui_layout:
+        if filename and self._gui_panel:
             file_selectors = self._get_selector('file')
 
             # Collapse FileSelector card
             file_selectors[1].collapsed = True
 
-            # Change plot button color to indicate change unless ms path not set previously
+            # Set filename from last file in file selector
             filename_input = file_selectors[0][0]
-            if filename_input.value:
-                self._update_plot_status(True)
-
-            # Set filename from last file in file selector (triggers _update_plot())
-            #filename_input.width = len(filename[-1])
             filename_input.value = filename[-1]
 
     def _set_iter_values(self, iter_axis):
         ''' Set up player with values when iter_axis is selected '''
         iter_axis = None if iter_axis == 'None' else iter_axis
-        if iter_axis and self._gui_layout:
-            iter_values = self._data.get_dimension_values(iter_axis)
+        if iter_axis and self._gui_panel:
+            iter_values = self._ms_data.get_dimension_values(iter_axis)
             if iter_values:
 
                 iter_selectors = self._get_selector('iter')
@@ -812,7 +737,7 @@ class MsRaster(MsPlot):
 
     def _get_datetime_values(self, float_times):
         ''' Return list of float time values as list of datetime values for gui options '''
-        time_attrs = self._data.get_dimension_attrs('time')
+        time_attrs = self._ms_data.get_dimension_attrs('time')
         datetime_values = []
         try:
             datetime_values = to_datetime(float_times, unit=time_attrs['units'], origin=time_attrs['format'])
@@ -822,118 +747,40 @@ class MsRaster(MsPlot):
 
     def _update_plot_spinner(self, plot_clicked):
         ''' Callback to start spinner when Plot button clicked. '''
-        if self._gui_layout:
+        if self._gui_panel:
             # Start spinner
-            spinner = self._gui_layout[2][2][1]
+            spinner = self._gui_panel[2][2][1]
             spinner.value = plot_clicked
 
     def _update_plot_status(self, plot_changed):
         ''' Change button color when plot inputs change. '''
-        if self._gui_layout:
+        if self._gui_panel:
             # Set button color
-            button = self._gui_layout[2][2][0]
+            button = self._gui_panel[2][2][0]
             button.button_style = 'solid' if plot_changed else 'outline'
 
     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()
-            for param in self._plot_params:
-                str_pane = pn.pane.Str(param)
-                str_pane.margin = (0, 10)
-                inputs_column.append(str_pane)
-
-    def _update_cursor_location(self, x, y):
-        ''' Show data values for cursor x,y position in cursor location box below plot '''
-        # Convert plot values to selection values to select plot data
-        x_axis = self._plot_inputs['x_axis']
-        y_axis = self._plot_inputs['y_axis']
-        cursor_position = {x_axis: x, y_axis: y}
-        cursor_location = locate_point(self._gui_plot_data, cursor_position, self._plot_inputs['vis_axis'])
-
-        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)
-        # Add row of columns to column layout
-        location_layout.append(location_row)
-        # Add column layout to widget box
-        cursor_location_box.append(location_layout)
-
-    def _layout_point_location(self, 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
-
-    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_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))
+        ''' Show inputs for raster plot in column in GUI tab '''
+        inputs_column = self._gui_panel[0][1]
+        super()._fill_inputs_column(inputs_column)
 
     ###
     ### Callbacks for widgets which update plot inputs
     ###
+    def _set_filename(self, filename):
+        ''' Set ms input from file text input '''
+        self._plot_inputs.set_input('ms', filename)
+        if self._set_ms(filename):
+            # New MS set, update gui input options
+            try:
+                self._update_gui_ms_options()
+                self._update_plot_status(True) # Change plot button to solid
+            except AttributeError:
+                self._update_plot_status(False)
+
     def _set_title(self, title):
         ''' Set title from gui text input '''
-        self._plot_inputs['title'] = title
+        self._plot_inputs.set_input('title', title)
         self._update_plot_status(True) # Change plot button to solid
 
     def _set_style_params(self, unflagged_cmap, flagged_cmap, show_colorbar, show_flagged_colorbar):
@@ -942,65 +789,59 @@ class MsRaster(MsPlot):
 
     def _set_color_range(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._plot_inputs['color_mode'] = color_mode
-        self._plot_inputs['color_range'] = color_range
+        self._plot_inputs.set_color_inputs(color_mode, color_range)
         self._update_plot_status(True) # Change plot button to solid
 
     def _set_axes(self, x_axis, y_axis, vis_axis):
-        ''' Set plot axis params from gui '''
-        self._plot_inputs['x_axis'] = x_axis
-        self._plot_inputs['y_axis'] = y_axis
-        self._plot_inputs['vis_axis'] = vis_axis
+        ''' Set plot axis inputs from gui '''
+        self._plot_inputs.set_axis_inputs(x_axis, y_axis, vis_axis)
         self._update_plot_status(True) # Change plot button to solid
 
     def _set_aggregation(self, aggregator, agg_axes):
         ''' Set aggregation params from gui '''
-        aggregator = None if aggregator== 'None' else aggregator
-        self._plot_inputs['aggregator'] = aggregator
-        self._plot_inputs['agg_axis'] = agg_axes # ignored if aggregator not set
+        self._plot_inputs.set_aggregation_inputs(aggregator, agg_axes)
         self._update_plot_status(True) # Change plot button to solid
 
 # pylint: disable=too-many-arguments, too-many-positional-arguments
     def _set_iteration(self, iter_axis, iter_value_type, iter_value, iter_start, iter_end, subplot_rows, subplot_columns):
         ''' Set iteration params from gui '''
         iter_axis = None if iter_axis == 'None' else iter_axis
-        self._plot_inputs['iter_axis'] = iter_axis
-        self._plot_inputs['subplots'] = (subplot_rows, subplot_columns)
-
+        iter_range = None
         if iter_axis:
+            # Set iter_range
             if iter_value_type == 'By Value':
                 # Use index of iter_value for tuple
-                if self._data and self._data.is_valid():
-                    iter_values = self._data.get_dimension_values(iter_axis)
+                if self._ms_data and self._ms_data.is_valid():
+                    iter_values = self._ms_data.get_dimension_values(iter_axis)
                     iter_index = iter_values.index(iter_value)
-                    self._plot_inputs['iter_range'] = (iter_index, iter_index)
+                    iter_range = (iter_index, iter_index)
             else:
                 # 'By Range': use range start and end values for tuple
-                self._plot_inputs['iter_range'] = (iter_start, iter_end)
-        else:
-            self._plot_inputs['iter_range'] = None
+                iter_range = (iter_start, iter_end)
+
+        self._plot_inputs.set_iteration_inputs(iter_axis, iter_range, subplot_rows, subplot_columns)
         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 '''
+        ''' Set ProcessingSet selection from gui using summary columns '''
         inputs = locals()
         ps_selection = {}
         for key, val in inputs.items():
             if key in PS_SELECTION_OPTIONS.values() and val:
                 ps_selection[key] = val
-        self._plot_inputs['ps_selection'] = ps_selection
+        self._gui_selection['ps_selection'] = ps_selection
         self._update_plot_status(True) # Change plot button to solid
 
     def _set_ms_selection(self, data_group, datetime, baseline, antenna1, antenna2, frequency, polarization):
-        ''' Select MeasurementSet from gui using data group, dimensions, and coordinates '''
+        ''' Set MeasurementSet selection from gui using data group, dimensions, and coordinates '''
         inputs = locals()
         inputs['time'] = inputs.pop('datetime')
         ms_selection = {}
         for key, val in inputs.items():
             if key in MS_SELECTION_OPTIONS.values() and val:
                 ms_selection[key] = val
-        self._plot_inputs['ms_selection'] = ms_selection
+        self._gui_selection['ms_selection'] = ms_selection
         self._update_plot_status(True) # Change plot button to solid
 # pylint: enable=too-many-arguments, too-many-positional-arguments, unused-argument