Merge remote-tracking branch 'matplotlib/master'

ericmjl · ericmjl · commit 030cd4b2e4a3 · 2015-08-23T17:42:37.000-04:00
diff --git a/doc/api/api_changes/2015-08-17-JRE.rst b/doc/api/api_changes/2015-08-17-JRE.rst
@@ -0,0 +1,11 @@
+ Preserve units with Text position
+ `````````````````````````````````
+
+Previously the 'get_position' method on Text would strip away unit information
+even though the units were still present.  There was no inherent need to do
+this, so it has been changed so that unit data (if present) will be preserved.
+Essentially a call to 'get_position' will return the exact value from a call to
+'set_position'.
+
+If you wish to get the old behaviour, then you can use the new method called
+'get_unitless_position'.
diff --git a/doc/mpl_toolkits/axes_grid/users/overview.rst b/doc/mpl_toolkits/axes_grid/users/overview.rst
@@ -464,7 +464,7 @@ Curvilinear Grid
 The motivation behind the AxisArtist module is to support curvilinear grid
 and ticks.
 
-.. plot:: mpl_toolkits/axes_grid/examples/demo_floating_axis.py
+.. plot:: mpl_toolkits/axes_grid/examples/demo_curvelinear_grid.py
 
 See :ref:`axisartist-manual` for more details.
 
diff --git a/doc/users/pyplot_tutorial.rst b/doc/users/pyplot_tutorial.rst
@@ -11,7 +11,10 @@ some change to a figure: e.g., create a figure, create a plotting area
 in a figure, plot some lines in a plotting area, decorate the plot
 with labels, etc....  :mod:`matplotlib.pyplot` is stateful, in that it
 keeps track of the current figure and plotting area, and the plotting
-functions are directed to the current axes
+functions are directed to the current axes (please note that "axes" here
+and in most places in the documentation refers to the *axes*
+`part of a figure <http://matplotlib.org/faq/usage_faq.html#parts-of-a-figure>`__
+and not the strict mathematical term for more than one axis).
 
 .. plot:: pyplots/pyplot_simple.py
    :include-source:
@@ -164,7 +167,7 @@ scenes.  Below is a script to create two subplots.
 
 The :func:`~matplotlib.pyplot.figure` command here is optional because
 ``figure(1)`` will be created by default, just as a ``subplot(111)``
-will be created by default if you don't manually specify an axes.  The
+will be created by default if you don't manually specify any axes.  The
 :func:`~matplotlib.pyplot.subplot` command specifies ``numrows,
 numcols, fignum`` where ``fignum`` ranges from 1 to
 ``numrows*numcols``.  The commas in the ``subplot`` command are
diff --git a/lib/matplotlib/animation.py b/lib/matplotlib/animation.py
@@ -1142,7 +1142,7 @@ def new_saved_frame_seq(self):
         if self._save_seq:
             # While iterating we are going to update _save_seq
             # so make a copy to safely iterate over
-            self._old_saved_seq = self._save_seq.copy()
+            self._old_saved_seq = list(self._save_seq)
             return iter(self._old_saved_seq)
         else:
             return itertools.islice(self.new_frame_seq(), self.save_count)
diff --git a/lib/matplotlib/backends/backend_qt5.py b/lib/matplotlib/backends/backend_qt5.py
@@ -416,7 +416,21 @@ def stop_event_loop(self):
     stop_event_loop.__doc__ = FigureCanvasBase.stop_event_loop_default.__doc__
 
     def draw_idle(self):
-        self.update()
+        # This cannot be a call to 'update', we need a slightly longer
+        # delay, otherwise mouse releases from zooming, panning, or
+        # lassoing might not finish processing and will not redraw properly.
+        # We use the guard flag to prevent infinite calls to 'draw_idle' which
+        # happens with the 'stale' figure & axes callbacks.
+        d = self._idle
+        self._idle = False
+
+        def idle_draw(*args):
+            try:
+                self.draw()
+            finally:
+                self._idle = True
+        if d:
+            QtCore.QTimer.singleShot(0, idle_draw)
 
 
 class MainWindow(QtWidgets.QMainWindow):
diff --git a/lib/matplotlib/backends/backend_qt5agg.py b/lib/matplotlib/backends/backend_qt5agg.py
@@ -71,7 +71,9 @@ def paintEvent(self, e):
         In Qt, all drawing should be done inside of here when a widget is
         shown onscreen.
         """
-        FigureCanvasAgg.draw(self)
+        # If we have not rendered the Agg backend yet, do so now.
+        if not hasattr(self, 'renderer'):
+            FigureCanvasAgg.draw(self)
 
         # FigureCanvasQT.paintEvent(self, e)
         if DEBUG:
diff --git a/lib/matplotlib/collections.py b/lib/matplotlib/collections.py
@@ -1053,6 +1053,7 @@ def __init__(self, segments,     # Can be None.
                  cmap=None,
                  pickradius=5,
                  zorder=2,
+                 facecolors='none',
                  **kwargs
                  ):
         """
@@ -1106,6 +1107,11 @@ def __init__(self, segments,     # Can be None.
         *zorder*
            The zorder of the LineCollection.  Default is 2
 
+        *facecolors*
+           The facecolors of the LineCollection. Default is 'none'
+           Setting to a value other than 'none' will lead to a filled
+           polygon being drawn between points on each line.
+
         The use of :class:`~matplotlib.cm.ScalarMappable` is optional.
         If the :class:`~matplotlib.cm.ScalarMappable` array
         :attr:`~matplotlib.cm.ScalarMappable._A` is not None (i.e., a call to
@@ -1124,7 +1130,7 @@ def __init__(self, segments,     # Can be None.
         Collection.__init__(
             self,
             edgecolors=colors,
-            facecolors='none',
+            facecolors=facecolors,
             linewidths=linewidths,
             linestyles=linestyles,
             antialiaseds=antialiaseds,
diff --git a/lib/matplotlib/font_manager.py b/lib/matplotlib/font_manager.py
@@ -1099,15 +1099,18 @@ def score_family(self, families, family2):
         Returns a match score between the list of font families in
         *families* and the font family name *family2*.
 
-        An exact match anywhere in the list returns 0.0.
+        An exact match at the head of the list returns 0.0.
 
-        A match by generic font name will return 0.1.
+        A match further down the list will return between 0 and 1.
 
         No match will return 1.0.
         """
         if not isinstance(families, (list, tuple)):
             families = [families]
+        elif len(families) == 0:
+            return 1.0
         family2 = family2.lower()
+        step = 1 / len(families)
         for i, family1 in enumerate(families):
             family1 = family1.lower()
             if family1 in font_family_aliases:
@@ -1117,12 +1120,11 @@ def score_family(self, families, family2):
                 options = [x.lower() for x in options]
                 if family2 in options:
                     idx = options.index(family2)
-                    return ((0.1 * (idx / len(options))) *
-                            ((i + 1) / len(families)))
+                    return (i + (idx / len(options))) * step
             elif family1 == family2:
                 # The score should be weighted by where in the
                 # list the font was found.
-                return i / len(families)
+                return i * step
         return 1.0
 
     def score_style(self, style1, style2):
diff --git a/lib/matplotlib/image.py b/lib/matplotlib/image.py
@@ -718,11 +718,15 @@ def get_cursor_data(self, event):
         arr = self.get_array()
         data_extent = mtransforms.Bbox([[ymin, xmin], [ymax, xmax]])
         array_extent = mtransforms.Bbox([[0, 0], arr.shape[:2]])
-        trans = mtransforms. BboxTransform(boxin=data_extent,
-                                           boxout=array_extent)
+        trans = mtransforms.BboxTransform(boxin=data_extent,
+                                          boxout=array_extent)
         y, x = event.ydata, event.xdata
         i, j = trans.transform_point([y, x]).astype(int)
-        return arr[i, j]
+        # Clip the coordinates at array bounds
+        if not (0 <= i < arr.shape[0]) or not (0 <= j < arr.shape[1]):
+            return None
+        else:
+            return arr[i, j]
 
 
 class NonUniformImage(AxesImage):
diff --git a/lib/matplotlib/lines.py b/lib/matplotlib/lines.py
@@ -568,13 +568,14 @@ def get_window_extent(self, renderer):
     def axes(self, ax):
         # call the set method from the base-class property
         Artist.axes.fset(self, ax)
-        # connect unit-related callbacks
-        if ax.xaxis is not None:
-            self._xcid = ax.xaxis.callbacks.connect('units',
-                                                    self.recache_always)
-        if ax.yaxis is not None:
-            self._ycid = ax.yaxis.callbacks.connect('units',
-                                                    self.recache_always)
+        if ax is not None:
+            # connect unit-related callbacks
+            if ax.xaxis is not None:
+                self._xcid = ax.xaxis.callbacks.connect('units',
+                                                        self.recache_always)
+            if ax.yaxis is not None:
+                self._ycid = ax.yaxis.callbacks.connect('units',
+                                                        self.recache_always)
 
     def set_data(self, *args):
         """
diff --git a/lib/matplotlib/tests/test_artist.py b/lib/matplotlib/tests/test_artist.py
@@ -150,21 +150,27 @@ def test_cull_markers():
 def test_remove():
     fig, ax = plt.subplots()
     im = ax.imshow(np.arange(36).reshape(6, 6))
+    ln, = ax.plot(range(5))
 
     assert_true(fig.stale)
     assert_true(ax.stale)
 
     fig.canvas.draw()
     assert_false(fig.stale)
     assert_false(ax.stale)
+    assert_false(ln.stale)
 
     assert_true(im in ax.mouseover_set)
+    assert_true(ln not in ax.mouseover_set)
     assert_true(im.axes is ax)
 
     im.remove()
+    ln.remove()
+
+    for art in [im, ln]:
+        assert_true(art.axes is None)
+        assert_true(art.figure is None)
 
-    assert_true(im.axes is None)
-    assert_true(im.figure is None)
     assert_true(im not in ax.mouseover_set)
     assert_true(fig.stale)
     assert_true(ax.stale)
diff --git a/lib/matplotlib/tests/test_image.py b/lib/matplotlib/tests/test_image.py
@@ -170,16 +170,36 @@ def test_cursor_data():
     xdisp, ydisp = ax.transData.transform_point([x, y])
 
     event = MouseEvent('motion_notify_event', fig.canvas, xdisp, ydisp)
-    assert im.get_cursor_data(event) == 44
+    z = im.get_cursor_data(event)
+    assert z == 44, "Did not get 44, got %d" % z
+
+    # Now try for a point outside the image
+    # Tests issue #4957
+    x, y = 10.1, 4
+    xdisp, ydisp = ax.transData.transform_point([x, y])
+
+    event = MouseEvent('motion_notify_event', fig.canvas, xdisp, ydisp)
+    z = im.get_cursor_data(event)
+    assert z is None, "Did not get None, got %d" % z
+
+    # Hmm, something is wrong here... I get 0, not None...
+    # But, this works further down in the tests with extents flipped
+    #x, y = 0.1, -0.1
+    #xdisp, ydisp = ax.transData.transform_point([x, y])
+    #event = MouseEvent('motion_notify_event', fig.canvas, xdisp, ydisp)
+    #z = im.get_cursor_data(event)
+    #assert z is None, "Did not get None, got %d" % z
 
     ax.clear()
+    # Now try with the extents flipped.
     im = ax.imshow(np.arange(100).reshape(10, 10), origin='lower')
 
     x, y = 4, 4
     xdisp, ydisp = ax.transData.transform_point([x, y])
 
     event = MouseEvent('motion_notify_event', fig.canvas, xdisp, ydisp)
-    assert im.get_cursor_data(event) == 44
+    z = im.get_cursor_data(event)
+    assert z == 44, "Did not get 44, got %d" % z
 
     fig, ax = plt.subplots()
     im = ax.imshow(np.arange(100).reshape(10, 10), extent=[0, 0.5, 0, 0.5])
@@ -188,7 +208,24 @@ def test_cursor_data():
     xdisp, ydisp = ax.transData.transform_point([x, y])
 
     event = MouseEvent('motion_notify_event', fig.canvas, xdisp, ydisp)
-    assert im.get_cursor_data(event) == 55
+    z = im.get_cursor_data(event)
+    assert z == 55, "Did not get 55, got %d" % z
+
+    # Now try for a point outside the image
+    # Tests issue #4957
+    x, y = 0.75, 0.25
+    xdisp, ydisp = ax.transData.transform_point([x, y])
+
+    event = MouseEvent('motion_notify_event', fig.canvas, xdisp, ydisp)
+    z = im.get_cursor_data(event)
+    assert z is None, "Did not get None, got %d" % z
+
+    x, y = 0.01, -0.01
+    xdisp, ydisp = ax.transData.transform_point([x, y])
+
+    event = MouseEvent('motion_notify_event', fig.canvas, xdisp, ydisp)
+    z = im.get_cursor_data(event)
+    assert z is None, "Did not get None, got %d" % z
 
 
 @image_comparison(baseline_images=['image_clip'])
diff --git a/lib/matplotlib/text.py b/lib/matplotlib/text.py
@@ -240,7 +240,8 @@ def update(self, kwargs):
         """
         bbox = kwargs.pop('bbox', None)
         super(Text, self).update(kwargs)
-        self.set_bbox(bbox)  # depends on font properties
+        if bbox:
+            self.set_bbox(bbox)  # depends on font properties
 
     def __getstate__(self):
         d = super(Text, self).__getstate__()
@@ -280,7 +281,7 @@ def contains(self, mouseevent):
 
     def _get_xy_display(self):
         'get the (possibly unit converted) transformed x, y in display coords'
-        x, y = self.get_position()
+        x, y = self.get_unitless_position()
         return self.get_transform().transform_point((x, y))
 
     def _get_multialignment(self):
@@ -536,8 +537,8 @@ def update_bbox_position_size(self, renderer):
 
             trans = self.get_transform()
 
-            # don't use self.get_position here, which refers to text position
-            # in Text, and dash position in TextWithDash:
+            # don't use self.get_unitless_position here, which refers to text
+            # position in Text, and dash position in TextWithDash:
             posx = float(self.convert_xunits(self._x))
             posy = float(self.convert_yunits(self._y))
 
@@ -877,12 +878,20 @@ def get_horizontalalignment(self):
         """
         return self._horizontalalignment
 
-    def get_position(self):
-        "Return the position of the text as a tuple (*x*, *y*)"
+    def get_unitless_position(self):
+        "Return the unitless position of the text as a tuple (*x*, *y*)"
+        # This will get the position with all unit information stripped away.
+        # This is here for convienience since it is done in several locations.
         x = float(self.convert_xunits(self._x))
         y = float(self.convert_yunits(self._y))
         return x, y
 
+    def get_position(self):
+        "Return the position of the text as a tuple (*x*, *y*)"
+        # This should return the same data (possible unitized) as was
+        # specified with 'set_x' and 'set_y'.
+        return self._x, self._y
+
     def get_prop_tup(self):
         """
         Return a hashable tuple of properties.
@@ -891,7 +900,7 @@ def get_prop_tup(self):
         want to cache derived information about text (e.g., layouts) and
         need to know if the text has changed.
         """
-        x, y = self.get_position()
+        x, y = self.get_unitless_position()
         return (x, y, self.get_text(), self._color,
                 self._verticalalignment, self._horizontalalignment,
                 hash(self._fontproperties),
@@ -950,7 +959,7 @@ def get_window_extent(self, renderer=None, dpi=None):
             raise RuntimeError('Cannot get window extent w/o renderer')
 
         bbox, info, descent = self._get_layout(self._renderer)
-        x, y = self.get_position()
+        x, y = self.get_unitless_position()
         x, y = self.get_transform().transform_point((x, y))
         bbox = bbox.translated(x, y)
         if dpi is not None:
@@ -1365,12 +1374,20 @@ def __init__(self,
 
         #self.set_bbox(dict(pad=0))
 
-    def get_position(self):
-        "Return the position of the text as a tuple (*x*, *y*)"
+    def get_unitless_position(self):
+        "Return the unitless position of the text as a tuple (*x*, *y*)"
+        # This will get the position with all unit information stripped away.
+        # This is here for convienience since it is done in several locations.
         x = float(self.convert_xunits(self._dashx))
         y = float(self.convert_yunits(self._dashy))
         return x, y
 
+    def get_position(self):
+        "Return the position of the text as a tuple (*x*, *y*)"
+        # This should return the same data (possibly unitized) as was
+        # specified with set_x and set_y
+        return self._dashx, self._dashy
+
     def get_prop_tup(self):
         """
         Return a hashable tuple of properties.
@@ -1402,7 +1419,7 @@ def update_coords(self, renderer):
         with respect to the actual canvas's coordinates we need to map
         back and forth.
         """
-        dashx, dashy = self.get_position()
+        dashx, dashy = self.get_unitless_position()
         dashlength = self.get_dashlength()
         # Shortcircuit this process if we don't have a dash
         if dashlength == 0.0:
