Changeset 9290b1a in sasview for src/sas

Timestamp:

Dec 16, 2016 12:43:18 PM (8 years ago)

Author:

Piotr Rozyczko <rozyczko@…>

Branches:

ESS_GUI, ESS_GUI_Docs, ESS_GUI_batch_fitting, ESS_GUI_bumps_abstraction, ESS_GUI_iss1116, ESS_GUI_iss879, ESS_GUI_iss959, ESS_GUI_opencl, ESS_GUI_ordering, ESS_GUI_sync_sascalc

Children:

d3ca363

Parents:

0ba0774

Message:

Added AddText? to plot, enabled legend drag - SASVIEW-378

Location:

src/sas/qtgui

Files:

• AddText.py (added)
• DataExplorer.py (modified) (2 diffs)
• GUITests.py (modified) (2 diffs)
• PlotUtilities.py (modified) (1 diff)
• Plotter.py (modified) (6 diffs)
• Plotter2D.py (modified) (2 diffs)
• PlotterBase.py (modified) (6 diffs)
• UI/AddTextUI.ui (added)
• UI/convert_all.sh (modified) (1 diff)
• UnitTesting/AddTextTest.py (added)
• UnitTesting/PlotterBaseTest.py (modified) (2 diffs)
• UnitTesting/PlotterTest.py (modified) (1 diff)
• run_tests.bat (modified) (1 diff)
• run_tests.sh (modified) (1 diff)

src/sas/qtgui/DataExplorer.py

@@ -401 +401 @@
         new_plot = Plotter(self)
 
-        def addDataPlot(plot, plot_set):
-            plot.data = plot_set
-            plot.plot()
-
         def addDataPlot2D(plot_set):
             plot2D = Plotter2D(self)
-            addDataPlot(plot2D, plot_set)
+            plot2D.plot(plot_set)
             self.plotAdd(plot2D)
 
         for plot_set in plots:
             if isinstance(plot_set, Data1D):
-                addDataPlot(new_plot, plot_set)
+                new_plot.plot(plot_set)
             elif isinstance(plot_set, Data2D):
                 addDataPlot2D(plot_set)
@@ -418 +414 @@
                 msg = "Incorrect data type passed to Plotting"
                 raise AttributeError, msg
-
 
         if plots and \

src/sas/qtgui/GUITests.py

@@ -2 +2 @@
 
 from UnitTesting import AboutBoxTest
+from UnitTesting import AddTextTest
 from UnitTesting import DataExplorerTest
 from UnitTesting import WelcomePanelTest
@@ -22 +23 @@
     suites = (
         unittest.makeSuite(AboutBoxTest.AboutBoxTest,          'test'),
+        unittest.makeSuite(AddTextTest.AddTextTest,          'test'),
         unittest.makeSuite(DataExplorerTest.DataExplorerTest,  'test'),
         unittest.makeSuite(WelcomePanelTest.WelcomePanelTest,  'test'),

src/sas/qtgui/PlotUtilities.py

@@ -175 +175 @@
 
     return image
+
+def rescale(lo, hi, step, pt=None, bal=None, scale='linear'):
+    """
+    Rescale (lo,hi) by step, returning the new (lo,hi)
+    The scaling is centered on pt, with positive values of step
+    driving lo/hi away from pt and negative values pulling them in.
+    If bal is given instead of point, it is already in [0,1] coordinates.
+
+    This is a helper function for step-based zooming.
+    """
+    # Convert values into the correct scale for a linear transformation
+    # TODO: use proper scale transformers
+    loprev = lo
+    hiprev = hi
+    if scale == 'log':
+        assert lo > 0
+        if lo > 0:
+            lo = numpy.log10(lo)
+        if hi > 0:
+            hi = numpy.log10(hi)
+        if pt is not None:
+            pt = numpy.log10(pt)
+
+    # Compute delta from axis range * %, or 1-% if persent is negative
+    if step > 0:
+        delta = float(hi - lo) * step / 100
+    else:
+        delta = float(hi - lo) * step / (100 - step)
+
+    # Add scale factor proportionally to the lo and hi values,
+    # preserving the
+    # point under the mouse
+    if bal is None:
+        bal = float(pt - lo) / (hi - lo)
+    lo = lo - (bal * delta)
+    hi = hi + (1 - bal) * delta
+
+    # Convert transformed values back to the original scale
+    if scale == 'log':
+        if (lo <= -250) or (hi >= 250):
+            lo = loprev
+            hi = hiprev
+        else:
+            lo, hi = numpy.power(10., lo), numpy.power(10., hi)
+    return (lo, hi)
+

src/sas/qtgui/Plotter.py

@@ -2 +2 @@
 
 import matplotlib.pyplot as plt
-
+from matplotlib.font_manager import FontProperties
+
+from sas.sasgui.guiframe.dataFitting import Data1D
 from sas.sasgui.plottools import transform
 from sas.sasgui.plottools.convert_units import convert_unit
 from sas.qtgui.PlotterBase import PlotterBase
+from sas.qtgui.AddText import AddText
 
 class PlotterWidget(PlotterBase):
@@ -27 +30 @@
         self.title(title=value.title)
 
-    def plot(self, marker=None, linestyle=None, hide_error=False):
+    def plot(self, data=None, marker=None, linestyle=None, hide_error=False):
         """
         Plot self._data
         """
+        # Data1D
+        if isinstance(data, Data1D):
+            self.data = data
+        assert(self._data)
+
         # Shortcut for an axis
         ax = self.ax
@@ -45 +53 @@
                     marker=marker,
                     linestyle=linestyle,
-                    label=self._title)
+                    label=self._title,
+                    picker=True)
         else:
             ax.errorbar(self._data.view.x, self._data.view.y,
@@ -54 +63 @@
                         lolims=False, uplims=False,
                         xlolims=False, xuplims=False,
-                        label=self._title)
+                        label=self._title,
+                        picker=True)
 
         # Now add the legend with some customizations.
-        legend = ax.legend(loc='upper right', shadow=True)
+        self.legend = ax.legend(loc='upper right', shadow=True)
+        #self.legend.get_frame().set_alpha(0.4)
+        self.legend.set_picker(True)
 
         # Current labels for axes
@@ -142 +154 @@
         Show a dialog allowing adding custom text to the chart
         """
-        print("onAddText")
-        pass
+        self.addText = AddText(self)
+        if self.addText.exec_() == QtGui.QDialog.Accepted:
+            # Retrieve the new text, its font and color
+            extra_text = self.addText.text()
+            extra_font = self.addText.font()
+            extra_color = self.addText.color()
+
+            # Place the text on the screen at (0,0)
+            pos_x = self.x_click
+            pos_y = self.y_click
+
+            # Map QFont onto MPL font
+            mpl_font = FontProperties()
+            mpl_font.set_size(int(extra_font.pointSize()))
+            mpl_font.set_family(str(extra_font.family()))
+            mpl_font.set_weight(int(extra_font.weight()))
+            # MPL style names
+            styles = ['normal', 'italic', 'oblique']
+            # QFont::Style maps directly onto the above
+            try:
+                mpl_font.set_style(styles[extra_font.style()])
+            except:
+                pass
+
+            if len(extra_text) > 0:
+                new_text = self.ax.text(str(pos_x),
+                                        str(pos_y),
+                                        extra_text,
+                                        color=extra_color,
+                                        fontproperties=mpl_font)
+                # Update the list of annotations
+                self.textList.append(new_text)
+                self.canvas.draw_idle()
 
     def onRemoveText(self):
         """
-        Remove the most recent added text
-        """
-        print("onRemoveText")
-        pass
+        Remove the most recently added text
+        """
+        num_text = len(self.textList)
+        if num_text < 1:
+            return
+        txt = self.textList[num_text - 1]
+        text_remove = txt.get_text()
+        txt.remove()
+        self.textList.remove(txt)
+
+        self.canvas.draw_idle()
 
     def onSetGraphRange(self):
@@ -172 +222 @@
         # Clear the plot first
         plt.cla()
+        self.ax.cla()
 
         # Changing the scale might be incompatible with

src/sas/qtgui/Plotter2D.py

@@ -6 +6 @@
 
 DEFAULT_CMAP = pylab.cm.jet
+from mpl_toolkits.mplot3d import Axes3D
 
 import sas.qtgui.PlotUtilities as PlotUtilities
 from sas.qtgui.PlotterBase import PlotterBase
-from mpl_toolkits.mplot3d import Axes3D
+from sas.sasgui.guiframe.dataFitting import Data2D
 
 # Minimum value of Z for which we will present data.
@@ -43 +44 @@
         self.title(title=data.title)
 
-    def plot(self, marker=None, linestyle=None):
+    def plot(self, data=None, marker=None, linestyle=None):
         """
         Plot 2D self._data
         """
+        # Assing data
+        if isinstance(data, Data2D):
+            self.data = data
+
+        assert(self._data)
+
         # Toggle the scale
         zmin_2D_temp = self.zmin

src/sas/qtgui/PlotterBase.py

@@ -1 +1 @@
 import pylab
+import numpy
 
 from PyQt4 import QtGui
@@ -13 +14 @@
 
 DEFAULT_CMAP = pylab.cm.jet
+from sas.sasgui.plottools.binder import BindArtist
+
 from sas.qtgui.ScaleProperties import ScaleProperties
 from sas.qtgui.WindowTitle import WindowTitle
 import sas.qtgui.PlotHelper as PlotHelper
+import sas.qtgui.PlotUtilities as PlotUtilities
 
 class PlotterBase(QtGui.QWidget):
@@ -53 +57 @@
         self.y_label = "log10(y)"
 
+        # Mouse click related
+        self.x_click = None
+        self.y_click = None
+        self.event_pos = None
+        self.leftdown = False
+        self.gotLegend = 0
+
+        # Annotations
+        self.selectedText = None
+        self.textList = []
+
         # Pre-define the Scale properties dialog
         self.properties = ScaleProperties(self,
@@ -66 +81 @@
         self.ax = self.figure.add_subplot(self.current_plot)
 
+        # Remove this, DAMMIT
+        self.axes = [self.ax]
+
         # Set the background color to white
         self.canvas.figure.set_facecolor('#FFFFFF')
+
+        # Canvas event handlers
+        self.canvas.mpl_connect('button_release_event', self.onMplMouseUp)
+        self.canvas.mpl_connect('button_press_event', self.onMplMouseDown)
+        self.canvas.mpl_connect('motion_notify_event', self.onMplMouseMotion)
+        self.canvas.mpl_connect('pick_event', self.onMplPick)
+        self.canvas.mpl_connect('scroll_event', self.onMplWheel)
 
         if not quickplot:
@@ -166 +191 @@
         """
         Define common context menu and associated actions for the MPL widget
-        TODO: move to plotter1d/plotter2d
         """
         raise NotImplementedError("Context menu method must be implemented in derived class.")
@@ -180 +204 @@
         Display the context menu
         """
-        self.contextMenu.exec_(self.canvas.mapToGlobal(event.pos()))
+        event_pos = event.pos()
+        self.contextMenu.exec_(self.canvas.mapToGlobal(event_pos))
+
+    def onMplMouseDown(self, event):
+        """
+        Left button down and ready to drag
+        """
+        # Check that the LEFT button was pressed
+        if event.button == 1:
+            self.leftdown = True
+            ax = event.inaxes
+            for text in self.textList:
+                if text.contains(event)[0]: # If user has clicked on text
+                    self.selectedText = text
+                    return
+
+            if ax != None:
+                self.xInit, self.yInit = event.xdata, event.ydata
+                try:
+                    self.x_click = float(event.xdata)  # / size_x
+                    self.y_click = float(event.ydata)  # / size_y
+                except:
+                    self.position = None
+
+    def onMplMouseUp(self, event):
+        """
+        Set the data coordinates of the click
+        """
+        self.x_click = event.xdata
+        self.y_click = event.ydata
+
+        # Check that the LEFT button was released
+        if event.button == 1:
+            self.leftdown = False
+            #self.leftup = True
+            self.selectedText = None
+
+        #release the legend
+        if self.gotLegend == 1:
+            self.gotLegend = 0
+
+    def onMplMouseMotion(self, event):
+        """
+        Check if the left button is press and the mouse in moving.
+        Compute delta for x and y coordinates and then perform the drag
+        """
+        if self.gotLegend == 1 and self.leftdown:
+            self.onLegendMotion(event)
+            return
+
+        if self.leftdown and self.selectedText is not None:
+            # User has clicked on text and is dragging
+            ax = event.inaxes
+            if ax != None:
+                # Only move text if mouse is within axes
+                self.selectedText.set_position((event.xdata, event.ydata))
+                self.canvas.draw_idle()
+            else:
+                # User has dragged outside of axes
+                self.selectedText = None
+            return
+
+    def onMplPick(self, event):
+        """
+        On pick legend
+        """
+        legend = self.legend
+        if event.artist == legend:
+            # Get the box of the legend.
+            bbox = self.legend.get_window_extent()
+            # Get mouse coordinates at time of pick.
+            self.mouse_x = event.mouseevent.x
+            self.mouse_y = event.mouseevent.y
+            # Get legend coordinates at time of pick.
+            self.legend_x = bbox.xmin
+            self.legend_y = bbox.ymin
+            # Indicate we picked up the legend.
+            self.gotLegend = 1
+
+            #self.legend.legendPatch.set_alpha(0.5)
+
+    def onLegendMotion(self, event):
+        """
+        On legend in motion
+        """
+        ax = event.inaxes
+        if ax == None:
+            return
+        # Event occurred inside a plotting area
+        lo_x, hi_x = ax.get_xlim()
+        lo_y, hi_y = ax.get_ylim()
+        # How much the mouse moved.
+        x = mouse_diff_x = self.mouse_x - event.x
+        y = mouse_diff_y = self.mouse_y - event.y
+        # Put back inside
+        if x < lo_x:
+            x = lo_x
+        if x > hi_x:
+            x = hi_x
+        if y < lo_y:
+            y = lo_y
+        if y > hi_y:
+            y = hi_y
+        # Move the legend from its previous location by that same amount
+        loc_in_canvas = self.legend_x - mouse_diff_x, \
+                        self.legend_y - mouse_diff_y
+        # Transform into legend coordinate system
+        trans_axes = self.legend.parent.transAxes.inverted()
+        loc_in_norm_axes = trans_axes.transform_point(loc_in_canvas)
+        self.legend_pos_loc = tuple(loc_in_norm_axes)
+        self.legend._loc = self.legend_pos_loc
+        # self.canvas.draw()
+        self.canvas.draw_idle()
+
+    def onMplWheel(self, event):
+        """
+        Process mouse wheel as zoom events
+        """
+        ax = event.inaxes
+        step = event.step
+
+        if ax != None:
+            # Event occurred inside a plotting area
+            lo, hi = ax.get_xlim()
+            lo, hi = PlotUtilities.rescale(lo, hi, step,
+                              pt=event.xdata, scale=ax.get_xscale())
+            if not self.xscale == 'log' or lo > 0:
+                self._scale_xlo = lo
+                self._scale_xhi = hi
+                ax.set_xlim((lo, hi))
+
+            lo, hi = ax.get_ylim()
+            lo, hi = PlotUtilities.rescale(lo, hi, step, pt=event.ydata,
+                              scale=ax.get_yscale())
+            if not self.yscale == 'log' or lo > 0:
+                self._scale_ylo = lo
+                self._scale_yhi = hi
+                ax.set_ylim((lo, hi))
+        else:
+            # Check if zoom happens in the axes
+            xdata, ydata = None, None
+            x, y = event.x, event.y
+
+            for ax in self.axes:
+                insidex, _ = ax.xaxis.contains(event)
+                if insidex:
+                    xdata, _ = ax.transAxes.inverted().transform_point((x, y))
+                insidey, _ = ax.yaxis.contains(event)
+                if insidey:
+                    _, ydata = ax.transAxes.inverted().transform_point((x, y))
+            if xdata is not None:
+                lo, hi = ax.get_xlim()
+                lo, hi = PlotUtilities.rescale(lo, hi, step,
+                                  bal=xdata, scale=ax.get_xscale())
+                if not self.xscale == 'log' or lo > 0:
+                    self._scale_xlo = lo
+                    self._scale_xhi = hi
+                    ax.set_xlim((lo, hi))
+            if ydata is not None:
+                lo, hi = ax.get_ylim()
+                lo, hi = PlotUtilities.rescale(lo, hi, step, bal=ydata,
+                                  scale=ax.get_yscale())
+                if not self.yscale == 'log' or lo > 0:
+                    self._scale_ylo = lo
+                    self._scale_yhi = hi
+                    ax.set_ylim((lo, hi))
+        self.canvas.draw_idle()
 
     def clean(self):

src/sas/qtgui/UI/convert_all.sh

@@ -1 +1 @@
 # UI -> PY
 for filename in *.ui; do
-  pyuic4 $filename > "`basename "$filename" .ui`.py"
+  pyuic.bat $filename > "`basename "$filename" .ui`.py"
 done
 

src/sas/qtgui/UnitTesting/PlotterBaseTest.py

@@ -157 +157 @@
 
     def testOnWindowsTitle(self):
-        ''' test changing the plot title'''
+        """ Test changing the plot title"""
         # Mock the modal dialog's response
         QtGui.QDialog.exec_ = MagicMock(return_value=QtGui.QDialog.Accepted)
@@ -171 +171 @@
         self.assertEqual(self.plotter.windowTitle(), "I am a new title")
 
+    def testOnMplMouseDown(self):
+        """ Test what happens on mouse click down in chart """
+        pass
+
+    def testOnMplMouseUp(self):
+        """ Test what happens on mouse release in chart """
+        pass
+
+    def testOnMplMouseMotion(self):
+        """ Test what happens on mouse move in chart """
+        pass
+
+    def testOnMplPick(self):
+        """ Test what happens on mouse pick in chart """
+        pass
+
+    def testOnMplWheel(self):
+        """ Test what happens on mouse pick in chart """
+        pass
+
 if __name__ == "__main__":
     unittest.main()

src/sas/qtgui/UnitTesting/PlotterTest.py

@@ -154 +154 @@
         self.assertEqual(self.plotter.ax.get_ylabel(), "$ \\ \\ ^{4}(()^{4})$")
 
+    def testAddText(self):
+        """ Checks the functionality of adding text to graph """
+        pass
+
+    def testOnRemoveText(self):
+        """ Cheks if annotations can be removed from the graph """
+        pass
+
+
 if __name__ == "__main__":
     unittest.main()

src/sas/qtgui/run_tests.bat

@@ -17 +17 @@
 python -m UnitTesting.ScalePropertiesTest
 python -m UnitTesting.WindowTitleTest
-
+python -m UnitTesting.AddTextTest

src/sas/qtgui/run_tests.sh

@@ -16 +16 @@
 python -m UnitTesting.DensityCalculatorTest
 python -m UnitTesting.WindowTitleTest
+python -m UnitTesting.AddTextTest