1728: Finishing the Q-Range Sliders

src/sas/qtgui/GUITests.py

@@ -57,6 +57,7 @@
 from Plotting.UnitTesting import PlotterBaseTest
 from Plotting.UnitTesting import PlotterTest
 from Plotting.UnitTesting import Plotter2DTest
+from Plotting.UnitTesting import QRangeSliderTests
 
 # Calculators
 from Calculators.UnitTesting import KiessigCalculatorTest
@@ -121,6 +122,7 @@ def plottingSuite():
         unittest.makeSuite(SlicerParametersTest.SlicerParametersTest, 'test'),
         unittest.makeSuite(PlotterBaseTest.PlotterBaseTest,           'test'),
         unittest.makeSuite(PlotterTest.PlotterTest,                   'test'),
+        unittest.makeSuite(QRangeSliderTests.QRangeSlidersTest,       'test'),
         )
     return unittest.TestSuite(suites)
 

src/sas/qtgui/MainWindow/DataExplorer.py

@@ -398,36 +398,12 @@ def allDataForModel(self, model):
             if data is None: continue
             # Now, all plots under this item
             name = data.name
-            ######################################################
-            # Reset all slider values in data so save/load does not choke on them
-            # Remove once slider definition moved out of PlotterData
-            data.slider_low_q_setter = None
-            data.slider_high_q_setter = None
-            data.slider_low_q_input = None
-            data.slider_high_q_input = None
-            data.slider_update_on_move = False
-            data.slider_low_q_getter = None
-            data.slider_high_q_getter = None
-            ######################################################
             is_checked = item.checkState()
             properties['checked'] = is_checked
-            other_datas = []
             # save underlying theories
             other_datas = GuiUtils.plotsFromDisplayName(name, model)
             # skip the main plot
             other_datas = list(other_datas.values())[1:]
-            for datas in other_datas:
-                ######################################################
-                # Reset all slider values in data so save/load does not choke on them
-                # Remove once slider definition moved out of PlotterData
-                datas.slider_low_q_setter = None
-                datas.slider_high_q_setter = None
-                datas.slider_low_q_input = None
-                datas.slider_high_q_input = None
-                datas.slider_update_on_move = False
-                datas.slider_low_q_getter = None
-                datas.slider_high_q_getter = None
-                ######################################################
             all_data[data.id] = [data, properties, other_datas]
         return all_data
 

src/sas/qtgui/MainWindow/GuiManager.py

@@ -60,6 +60,9 @@
 
 logger = logging.getLogger(__name__)
 
+# Expose the loaded perspectives for easy linking between perspective methods/inputs and plots
+LOADED_PERSPECTIVES = {}
+
 
 class GuiManager(object):
     """
@@ -192,6 +195,8 @@ def loadAllPerspectives(self):
             except Exception as e:
                 logger.warning(f"Unable to load {name} perspective.\n{e}")
         self.loadedPerspectives = loaded_dict
+        global LOADED_PERSPECTIVES
+        LOADED_PERSPECTIVES = self.loadedPerspectives
 
     def closeAllPerspectives(self):
         # Close all perspectives if they are open
@@ -205,6 +210,8 @@ def closeAllPerspectives(self):
                 except Exception as e:
                     logger.warning(f"Unable to close {name} perspective\n{e}")
         self.loadedPerspectives = {}
+        global LOADED_PERSPECTIVES
+        LOADED_PERSPECTIVES = self.loadedPerspectives
         self._current_perspective = None
 
     def addCategories(self):

src/sas/qtgui/Perspectives/Fitting/FittingWidget.py

@@ -2964,10 +2964,12 @@ def complete1D(self, return_data):
         fitted_data.show_q_range_sliders = True
         # Suppress the GUI update until the move is finished to limit model calculations
         fitted_data.slider_update_on_move = False
-        fitted_data.slider_high_q_input = self.options_widget.txtMaxRange
-        fitted_data.slider_high_q_setter = self.options_widget.updateMaxQ
-        fitted_data.slider_low_q_input = self.options_widget.txtMinRange
-        fitted_data.slider_low_q_setter = self.options_widget.updateMinQ
+        fitted_data.slider_tab_name = self.modelName()
+        fitted_data.slider_perspective_name = 'Fitting'
+        fitted_data.slider_high_q_input = ['options_widget', 'txtMaxRange']
+        fitted_data.slider_high_q_setter = ['options_widget', 'updateMaxQ']
+        fitted_data.slider_low_q_input = ['options_widget', 'txtMinRange']
+        fitted_data.slider_low_q_setter = ['options_widget', 'updateMinQ']
 
         self.model_data = fitted_data
         new_plots = [fitted_data]

src/sas/qtgui/Perspectives/Invariant/InvariantPerspective.py

@@ -148,15 +148,17 @@ def set_low_q_extrapolation_upper_limit(self, value):
         n_pts = (np.abs(self._data.x - value)).argmin() + 1
         item = QtGui.QStandardItem(str(n_pts))
         self.model.setItem(WIDGETS.W_NPTS_LOWQ, item)
+        self.txtNptsLowQ.setText(str(n_pts))
 
     def get_high_q_extrapolation_lower_limit(self):
         q_value = self._data.x[len(self._data.x) - int(self.txtNptsHighQ.text()) - 1]
         return q_value
 
     def set_high_q_extrapolation_lower_limit(self, value):
-        n_pts = (np.abs(self._data.x - value)).argmin() + 1
+        n_pts = len(self._data.x) - (np.abs(self._data.x - value)).argmin() + 1
         item = QtGui.QStandardItem(str(int(n_pts)))
         self.model.setItem(WIDGETS.W_NPTS_HIGHQ, item)
+        self.txtNptsHighQ.setText(str(n_pts))
 
     def enabling(self):
         """ """
@@ -260,27 +262,27 @@ def plotResult(self, model):
             self.high_extrapolation_plot.plot_role = Data1D.ROLE_DEFAULT
             self.high_extrapolation_plot.symbol = "Line"
             self.high_extrapolation_plot.show_errors = False
-            # TODO: Fix the link between npts and q and then enable the q-range sliders
-            #self.high_extrapolation_plot.show_q_range_sliders = True
-            #self.high_extrapolation_plot.slider_update_on_move = False
-            #self.high_extrapolation_plot.slider_low_q_input = self.txtNptsHighQ
-            #self.high_extrapolation_plot.slider_low_q_setter = self.set_high_q_extrapolation_lower_limit
-            #self.high_extrapolation_plot.slider_low_q_getter = self.get_high_q_extrapolation_lower_limit
-            #self.high_extrapolation_plot.slider_high_q_input = self.txtExtrapolQMax
+            self.high_extrapolation_plot.show_q_range_sliders = True
+            self.high_extrapolation_plot.slider_update_on_move = False
+            self.high_extrapolation_plot.slider_perspective_name = self.name
+            self.high_extrapolation_plot.slider_low_q_input = ['txtNptsHighQ']
+            self.high_extrapolation_plot.slider_low_q_setter = ['set_high_q_extrapolation_lower_limit']
+            self.high_extrapolation_plot.slider_low_q_getter = ['get_high_q_extrapolation_lower_limit']
+            self.high_extrapolation_plot.slider_high_q_input = ['txtExtrapolQMax']
             GuiUtils.updateModelItemWithPlot(self._model_item, self.high_extrapolation_plot,
                                              self.high_extrapolation_plot.title)
             plots.append(self.high_extrapolation_plot)
         if self.low_extrapolation_plot:
             self.low_extrapolation_plot.plot_role = Data1D.ROLE_DEFAULT
             self.low_extrapolation_plot.symbol = "Line"
             self.low_extrapolation_plot.show_errors = False
-            # TODO: Fix the link between npts and q and then enable the q-range sliders
-            #self.low_extrapolation_plot.show_q_range_sliders = True
-            #self.low_extrapolation_plot.slider_update_on_move = False
-            #self.low_extrapolation_plot.slider_high_q_input = self.txtNptsLowQ
-            #self.low_extrapolation_plot.slider_high_q_setter = self.set_low_q_extrapolation_upper_limit
-            #self.low_extrapolation_plot.slider_high_q_getter = self.get_low_q_extrapolation_upper_limit
-            #self.low_extrapolation_plot.slider_low_q_input = self.txtExtrapolQMin
+            self.low_extrapolation_plot.show_q_range_sliders = True
+            self.low_extrapolation_plot.slider_update_on_move = False
+            self.low_extrapolation_plot.slider_perspective_name = self.name
+            self.low_extrapolation_plot.slider_high_q_input = ['txtNptsLowQ']
+            self.low_extrapolation_plot.slider_high_q_setter = ['set_low_q_extrapolation_upper_limit']
+            self.low_extrapolation_plot.slider_high_q_getter = ['get_low_q_extrapolation_upper_limit']
+            self.low_extrapolation_plot.slider_low_q_input = ['txtExtrapolQMin']
             GuiUtils.updateModelItemWithPlot(self._model_item, self.low_extrapolation_plot,
                                              self.low_extrapolation_plot.title)
             plots.append(self.low_extrapolation_plot)
@@ -571,12 +573,16 @@ def setupSlots(self):
 
         self.txtNptsHighQ.textChanged.connect(self.checkLength)
 
+        self.txtExtrapolQMin.editingFinished.connect(self.checkQMinRange)
         self.txtExtrapolQMin.textChanged.connect(self.checkQMinRange)
 
+        self.txtExtrapolQMax.editingFinished.connect(self.checkQMaxRange)
         self.txtExtrapolQMax.textChanged.connect(self.checkQMaxRange)
 
+        self.txtNptsLowQ.editingFinished.connect(self.checkQRange)
         self.txtNptsLowQ.textChanged.connect(self.checkQRange)
 
+        self.txtNptsHighQ.editingFinished.connect(self.checkQRange)
         self.txtNptsHighQ.textChanged.connect(self.checkQRange)
 
     def stateChanged(self):
@@ -639,12 +645,22 @@ def checkQExtrapolatedData(self):
                                        self._path, name,
                                        self.sender().checkState())
 
-    def checkQMaxRange(self):
+    def checkQMaxRange(self, value=None):
+        if not value:
+            value = float(self.txtExtrapolQMax.text()) if self.txtExtrapolQMax.text() else ''
+        if value == '':
+            self.model.setItem(WIDGETS.W_EX_QMAX, QtGui.QStandardItem(value))
+            return
         item = QtGui.QStandardItem(self.txtExtrapolQMax.text())
         self.model.setItem(WIDGETS.W_EX_QMAX, item)
         self.checkQRange()
 
-    def checkQMinRange(self):
+    def checkQMinRange(self, value=None):
+        if not value:
+            value = float(self.txtExtrapolQMin.text()) if self.txtExtrapolQMin.text() else ''
+        if value == '':
+            self.model.setItem(WIDGETS.W_EX_QMIN, QtGui.QStandardItem(value))
+            return
         item = QtGui.QStandardItem(self.txtExtrapolQMin.text())
         self.model.setItem(WIDGETS.W_EX_QMIN, item)
         self.checkQRange()

src/sas/qtgui/Perspectives/Inversion/InversionPerspective.py

@@ -670,10 +670,10 @@ def removeData(self, data_list=None):
             self._dataList.pop(data, None)
         if self.dataPlot:
             # Reset dataplot sliders
-            self.dataPlot.slider_low_q_input = None
-            self.dataPlot.slider_high_q_input = None
-            self.dataPlot.slider_low_q_setter = None
-            self.dataPlot.slider_high_q_setter = None
+            self.dataPlot.slider_low_q_input = []
+            self.dataPlot.slider_high_q_input = []
+            self.dataPlot.slider_low_q_setter = []
+            self.dataPlot.slider_high_q_setter = []
         self._data = None
         length = len(self.dataList)
         for index in reversed(range(length)):
@@ -1047,10 +1047,12 @@ def _calculateUpdate(self, output_tuple):
         self.dataPlot.filename = self.logic.data.filename
 
         self.dataPlot.show_q_range_sliders = True
-        self.dataPlot.slider_low_q_input = self.minQInput
-        self.dataPlot.slider_low_q_setter = self.check_q_low
-        self.dataPlot.slider_high_q_input = self.maxQInput
-        self.dataPlot.slider_high_q_setter = self.check_q_high
+        self.dataPlot.slider_update_on_move = False
+        self.dataPlot.slider_perspective_name = "Inversion"
+        self.dataPlot.slider_low_q_input = ['minQInput']
+        self.dataPlot.slider_low_q_setter = ['check_q_low']
+        self.dataPlot.slider_high_q_input = ['maxQInput']
+        self.dataPlot.slider_high_q_setter = ['check_q_high']
 
         # Udpate internals and GUI
         self.updateDataList(self._data)

src/sas/qtgui/Plotting/LinearFit.py

@@ -3,6 +3,8 @@
 """
 import re
 import numpy
+from numbers import Number
+from typing import Optional
 from PyQt5 import QtCore
 from PyQt5 import QtGui
 from PyQt5 import QtWidgets
@@ -12,12 +14,14 @@
 from sas.qtgui.Plotting import Fittings
 from sas.qtgui.Plotting import DataTransform
 from sas.qtgui.Plotting.LineModel import LineModel
+from sas.qtgui.Plotting.QRangeSlider import QRangeSlider
 import sas.qtgui.Utilities.GuiUtils as GuiUtils
 
 # Local UI
 from sas.qtgui.UI import main_resources_rc
 from sas.qtgui.Plotting.UI.LinearFitUI import Ui_LinearFitUI
 
+
 class LinearFit(QtWidgets.QDialog, Ui_LinearFitUI):
     updatePlot = QtCore.pyqtSignal(tuple)
     def __init__(self, parent=None,
@@ -26,7 +30,7 @@ def __init__(self, parent=None,
                  fit_range=(0.0, 0.0),
                  xlabel="",
                  ylabel=""):
-        super(LinearFit, self).__init__()
+        super(LinearFit, self).__init__(parent)
 
         self.setupUi(self)
         # disable the context help icon
@@ -100,6 +104,9 @@ def __init__(self, parent=None,
         self.cstB = Fittings.Parameter(self.model, 'B', self.default_B)
         self.transform = DataTransform
 
+        self.q_sliders = None
+        self.drawSliders()
+
         self.setFixedSize(self.minimumSizeHint())
 
         # connect Fit button
@@ -239,7 +246,9 @@ def fit(self, event):
         tempx = numpy.array(tempx)
         tempy = numpy.array(tempy)
 
+        self.clearSliders()
         self.updatePlot.emit((tempx, tempy))
+        self.drawSliders()
 
     def origData(self):
         # Store the transformed values of view x, y and dy before the fit
@@ -314,4 +323,29 @@ def floatInvTransform(self, x):
             return numpy.sqrt(numpy.sqrt(numpy.power(10.0, x)))
         return x
 
-
+    def drawSliders(self):
+        """Show new Q-range sliders"""
+        self.data.show_q_range_sliders = True
+        self.q_sliders = QRangeSlider(self.parent, self.parent.ax, data=self.data)
+        self.q_sliders.line_min.input = self.txtFitRangeMin
+        self.q_sliders.line_max.input = self.txtFitRangeMax
+        # Ensure values are updated on redraw of plots
+        self.q_sliders.line_min.inputChanged()
+        self.q_sliders.line_max.inputChanged()
+
+    def clearSliders(self):
+        """Clear existing sliders"""
+        if self.q_sliders:
+            self.q_sliders.clear()
+        self.data.show_q_range_sliders = False
+        self.q_sliders = None
+
+    def closeEvent(self, ev):
+        self.clearSliders()
+        self.parent.update()
+
+    def accept(self, ev):
+        self.close()
+
+    def reject(self, ev):
+        self.close()

src/sas/qtgui/Plotting/Plotter.py

@@ -252,7 +252,12 @@ def plot(self, data=None, color=None, marker=None, hide_error=False, transform=T
 
         # Add q-range sliders
         if data.show_q_range_sliders:
+            # Grab existing slider if it exists
+            existing_slider = self.sliders.pop(data.name, None)
             sliders = QRangeSlider(self, self.ax, data=data)
+            # New sliders should be visible but existing sliders that were turned off should remain off
+            if existing_slider is not None and not existing_slider.is_visible:
+                sliders.toggle()
             self.sliders[data.name] = sliders
 
         # refresh canvas
@@ -338,6 +343,11 @@ def addPlotsToContextMenu(self):
             self.actionRemovePlot.triggered.connect(
                                 functools.partial(self.onRemovePlot, id))
 
+            if plot.show_q_range_sliders:
+                self.actionToggleSlider = plot_menu.addAction("Toggle Q-Range Slider Visibility")
+                self.actionToggleSlider.triggered.connect(
+                                    functools.partial(self.toggleSlider, id))
+
             if not plot.is_data:
                 self.actionFreeze = plot_menu.addAction('&Freeze')
                 self.actionFreeze.triggered.connect(
@@ -540,7 +550,6 @@ def removePlot(self, id):
 
         # Remove the plot from the list of plots
         self.plot_dict.pop(id)
-        self.sliders.pop(id, None)
 
         # Labels might have been changed
         xl = self.ax.xaxis.label.get_text()
@@ -561,6 +570,11 @@ def removePlot(self, id):
         self.ax.set_ylabel(yl)
         self.canvas.draw_idle()
 
+    def toggleSlider(self, id):
+        if id in self.sliders.keys():
+            slider = self.sliders.get(id)
+            slider.toggle()
+
     def onFreeze(self, id):
         """
         Freezes the selected plot to a separate chart

src/sas/qtgui/Plotting/PlotterData.py

@@ -47,16 +47,18 @@ def __init__(self, x=None, y=None, dx=None, dy=None):
         # Q-range slider definitions
         self.show_q_range_sliders = False  # Should sliders be shown?
         self.slider_update_on_move = True  # Should the gui update during the move?
+        self.slider_perspective_name = ""  # Name of the perspective that this slider is associated with
+        self.slider_tab_name = ""          # Name of the tab where the data set is
         # The following q-range slider variables are optional but help tie
         #   the slider to a GUI element for 2-way updates
-        self.slider_low_q_input = None  # Qt input that is tied to low-Q
-        self.slider_high_q_input = None  # Qt input that is tied to high-Q
+        self.slider_low_q_input = []  # List of attributes that lead to a Qt input to tie a low Q input to the slider
+        self.slider_high_q_input = []  # List of attributes that lead to a Qt input to tie a high Q input to the slider
         # Setters and getters are only needed for inputs that aren't Q values
         #   e.g. Invariant perspective nPts
-        self.slider_low_q_setter = None  # Callback method to set the low-Q value
-        self.slider_low_q_getter = None  # Callback method to get the low-Q value
-        self.slider_high_q_setter = None  # Callback method to set the high-Q value
-        self.slider_high_q_getter = None  # Callback method to get the high-Q value
+        self.slider_low_q_setter = []  # List of attributes that lead to a setter to tie a low Q method to the slider
+        self.slider_low_q_getter = []  # List of attributes that lead to a getter to tie a low Q method to the slider
+        self.slider_high_q_setter = []  # List of attributes that lead to a setter to tie a high Q method to the slider
+        self.slider_high_q_getter = []  # List of attributes that lead to a getter to tie a high Q method to the slider
 
     def copy_from_datainfo(self, data1d):
         """