Sticky margins cancellation system.

anntzer · anntzer · commit 832884eef73e · 2016-11-16T22:10:07.000-08:00
Let artists register lists of "sticky" x and y values.  If an edge of
the union of bounding boxes ends up falling on a sticky value, do not
add margins to that edge.

Docs still missing.
diff --git a/lib/matplotlib/artist.py b/lib/matplotlib/artist.py
@@ -2,7 +2,7 @@
                         unicode_literals)
 
 import six
-from collections import OrderedDict
+from collections import OrderedDict, namedtuple
 
 import re
 import warnings
@@ -76,6 +76,9 @@ def _stale_axes_callback(self, val):
         self.axes.stale = val
 
 
+_XYPair = namedtuple("_XYPair", "x y")
+
+
 class Artist(object):
     """
     Abstract base class for someone who renders into a
@@ -123,8 +126,7 @@ def __init__(self):
         self._snap = None
         self._sketch = rcParams['path.sketch']
         self._path_effects = rcParams['path.effects']
-
-        self._margins = {}
+        self._stickies = _XYPair([], [])
 
     def __getstate__(self):
         d = self.__dict__.copy()
@@ -926,98 +928,13 @@ def set_zorder(self, level):
         self.pchanged()
         self.stale = True
 
-    def get_top_margin(self):
+    def get_stickies(self):
         """
-        Get whether a margin should be applied to the top of the Artist.
-        """
-        return self._margins.get('top', True)
+        Get the `x` and `y` sticky lists for the artist.
 
-    def set_top_margin(self, margin):
-        """
-        Set whether a margin should be applied to the top of the Artist.
-        """
-        if margin != self._margins.get('top', True):
-            self.stale = True
-        self._margins['top'] = margin
-
-    top_margin = property(get_top_margin, set_top_margin)
-
-    def get_bottom_margin(self):
-        """
-        Get whether a margin should be applied to the bottom of the Artist.
-        """
-        return self._margins.get('bottom', True)
-
-    def set_bottom_margin(self, margin):
-        """
-        Set whether a margin should be applied to the bottom of the Artist.
-        """
-        if margin != self._margins.get('bottom', True):
-            self.stale = True
-        self._margins['bottom'] = margin
-
-    bottom_margin = property(get_bottom_margin, set_bottom_margin)
-
-    def get_left_margin(self):
-        """
-        Get whether a margin should be applied to the left of the Artist.
-        """
-        return self._margins.get('left', True)
-
-    def set_left_margin(self, margin):
-        """
-        Set whether a margin should be applied to the left of the Artist.
+        There is no setter; the lists should be modified in place as needed.
         """
-        if margin != self._margins.get('left', True):
-            self.stale = True
-        self._margins['left'] = margin
-
-    left_margin = property(get_left_margin, set_left_margin)
-
-    def get_right_margin(self):
-        """
-        Get whether a margin should be applied to the right of the Artist.
-        """
-        return self._margins.get('right', True)
-
-    def set_right_margin(self, margin):
-        """
-        Set whether a margin should be applied to the right of the Artist.
-        """
-        if margin != self._margins.get('right', True):
-            self.stale = True
-        self._margins['right'] = margin
-
-    right_margin = property(get_right_margin, set_right_margin)
-
-    def get_margins(self):
-        """
-        Returns a dictionary describing whether a margin should be applied on
-        each of the sides (top, bottom, left and right).
-        """
-        return self._margins
-
-    def set_margins(self, margins):
-        """
-        Set the dictionary describing whether a margin should be applied on
-        each of the sides (top, bottom, left and right).  Missing keys are
-        assumed to be `True`.  If `True` or `False` are passed in, all
-        sides are set to that value.
-        """
-        if margins in (True, False):
-            margins = {
-                'top': margins,
-                'bottom': margins,
-                'left': margins,
-                'right': margins
-            }
-
-        if margins != self._margins:
-            self.stale = True
-
-        self._margins = margins
-
-    margins = property(get_margins, set_margins)
+        return self._stickies
 
     def update_from(self, other):
         'Copy properties from *other* to *self*.'
diff --git a/lib/matplotlib/axes/_axes.py b/lib/matplotlib/axes/_axes.py
@@ -2097,13 +2097,6 @@ def make_iterable(x):
             if yerr is not None:
                 yerr = self.convert_yunits(yerr)
 
-        margins = {}
-
-        if orientation == 'vertical':
-            margins = {'bottom': False}
-        elif orientation == 'horizontal':
-            margins = {'left': False}
-
         if align == 'center':
             if orientation == 'vertical':
                 left = [left[i] - width[i] / 2. for i in xrange(len(left))]
@@ -2128,11 +2121,13 @@ def make_iterable(x):
                 edgecolor=e,
                 linewidth=lw,
                 label='_nolegend_',
-                margins=margins
                 )
             r.update(kwargs)
             r.get_path()._interpolation_steps = 100
-            #print r.get_label(), label, 'label' in kwargs
+            x_stickies, y_stickies = r.get_stickies()
+            (getattr(r.get_stickies(),
+                     {'vertical': 'y', 'horizontal': 'x'}[orientation])
+             .append(0))
             self.add_patch(r)
             patches.append(r)
 
@@ -5466,7 +5461,7 @@ def pcolor(self, *args, **kwargs):
 
         kwargs.setdefault('snap', False)
 
-        collection = mcoll.PolyCollection(verts, margins=False, **kwargs)
+        collection = mcoll.PolyCollection(verts, **kwargs)
 
         collection.set_alpha(alpha)
         collection.set_array(C)
@@ -5500,8 +5495,11 @@ def pcolor(self, *args, **kwargs):
         miny = np.amin(y)
         maxy = np.amax(y)
 
-        corners = (minx, miny), (maxx, maxy)
         self.add_collection(collection, autolim=False)
+        corners = (minx, miny), (maxx, maxy)
+        stickies = collection.get_stickies()
+        stickies.x = [minx, maxx]
+        stickies.y = [miny, maxy]
         self.update_datalim(corners)
         self.autoscale_view()
         return collection
@@ -5617,10 +5615,9 @@ def pcolormesh(self, *args, **kwargs):
         coords[:, 0] = X
         coords[:, 1] = Y
 
-        collection = mcoll.QuadMesh(
-            Nx - 1, Ny - 1, coords,
-            antialiased=antialiased, shading=shading, margins=False,
-            **kwargs)
+        collection = mcoll.QuadMesh(Nx - 1, Ny - 1, coords,
+                                    antialiased=antialiased, shading=shading,
+                                    **kwargs)
         collection.set_alpha(alpha)
         collection.set_array(C)
         if norm is not None and not isinstance(norm, mcolors.Normalize):
@@ -5651,8 +5648,11 @@ def pcolormesh(self, *args, **kwargs):
         miny = np.amin(Y)
         maxy = np.amax(Y)
 
-        corners = (minx, miny), (maxx, maxy)
         self.add_collection(collection, autolim=False)
+        corners = (minx, miny), (maxx, maxy)
+        stickies = collection.get_stickies()
+        stickies.x = [minx, maxx]
+        stickies.y = [miny, maxy]
         self.update_datalim(corners)
         self.autoscale_view()
         return collection
@@ -5804,8 +5804,7 @@ def pcolorfast(self, *args, **kwargs):
             # The QuadMesh class can also be changed to
             # handle relevant superclass kwargs; the initializer
             # should do much more than it does now.
-            collection = mcoll.QuadMesh(nc, nr, coords, 0, edgecolors="None",
-                                        margins=False)
+            collection = mcoll.QuadMesh(nc, nr, coords, 0, edgecolors="None")
             collection.set_alpha(alpha)
             collection.set_array(C)
             collection.set_cmap(cmap)
@@ -5842,6 +5841,9 @@ def pcolorfast(self, *args, **kwargs):
             ret.set_clim(vmin, vmax)
         else:
             ret.autoscale_None()
+        stickies = collection.get_stickies()
+        stickies.x = [xl, xr]
+        stickies.y = [yb, yt]
         self.update_datalim(np.array([[xl, yb], [xr, yt]]))
         self.autoscale_view(tight=True)
         return ret
@@ -6254,11 +6256,6 @@ def _normalize_input(inp, ename='input'):
             else:
                 n = [m[slc].cumsum()[slc] for m in n]
 
-        if orientation == 'horizontal':
-            margins = {'left': False}
-        else:
-            margins = {'bottom': False}
-
         patches = []
 
         if histtype.startswith('bar'):
@@ -6403,8 +6400,11 @@ def _normalize_input(inp, ename='input'):
                     closed=True if fill else None,
                     facecolor=c,
                     edgecolor=None if fill else c,
-                    fill=fill if fill else None,
-                    margins=margins))
+                    fill=fill if fill else None))
+            for patch in patches:
+                (getattr(patch.get_stickies(),
+                         {'vertical': 'y', 'horizontal': 'x'}[orientation])
+                 .append(0))
 
             # we return patches, so put it back in the expected order
             patches.reverse()
diff --git a/lib/matplotlib/axes/_base.py b/lib/matplotlib/axes/_base.py
@@ -2199,53 +2199,19 @@ def autoscale_view(self, tight=None, scalex=True, scaley=True):
         case, use :meth:`matplotlib.axes.Axes.relim` prior to calling
         autoscale_view.
         """
-        if tight is None:
-            _tight = self._tight
-        else:
-            _tight = self._tight = bool(tight)
+        if tight is not None:
+            self._tight = bool(tight)
 
         if self._xmargin or self._ymargin:
-            margins = {
-                'top': True,
-                'bottom': True,
-                'left': True,
-                'right': True
-            }
-            for artist_set in [self.collections, self.patches, self.lines,
-                               self.artists, self.images]:
-                for artist in artist_set:
-                    artist_margins = artist.margins
-                    for key in ['left', 'right', 'top', 'bottom']:
-                        margins[key] &= artist_margins.get(key, True)
-
-            if self._xmargin:
-                for axes in self._shared_x_axes.get_siblings(self):
-                    for artist_set in [axes.collections, axes.patches,
-                                       axes.lines, axes.artists, axes.images]:
-                        for artist in artist_set:
-                            artist_margins = artist.margins
-                            for key in ['left', 'right']:
-                                margins[key] &= artist_margins.get(key, True)
-
-            if self._ymargin:
-                for axes in self._shared_y_axes.get_siblings(self):
-                    for artist_set in [axes.collections, axes.patches,
-                                       axes.lines, axes.artists, axes.images]:
-                        for artist in artist_set:
-                            artist_margins = artist.margins
-                            for key in ['top', 'bottom']:
-                                margins[key] &= artist_margins.get(key, True)
-        else:
-            margins = {
-                'top': False,
-                'bottom': False,
-                'left': False,
-                'right': False
-            }
+            stickies = [artist.get_stickies()
+                        for artist in self.get_children()]
+            x_stickies = [sticky.x for sticky in stickies]
+            y_stickies = [sticky.y for sticky in stickies]
+        else:  # Small optimization.
+            x_stickies, y_stickies = [], []
 
         def handle_single_axis(scale, autoscaleon, shared_axes, interval,
-                               minpos, axis, margin, do_lower_margin,
-                               do_upper_margin, set_bound):
+                               minpos, axis, margin, stickies, set_bound):
 
             if not (scale and autoscaleon):
                 return  # nothing to do...
@@ -2268,43 +2234,33 @@ def handle_single_axis(scale, autoscaleon, shared_axes, interval,
                 x0, x1 = mtransforms.nonsingular(
                     x0, x1, increasing=False, expander=0.05)
 
-            if margin > 0 and (do_lower_margin or do_upper_margin):
-                if axis.get_scale() == 'linear':
-                    delta = (x1 - x0) * margin
-                    if do_lower_margin:
-                        x0 -= delta
-                    if do_upper_margin:
-                        x1 += delta
-                else:
-                    # If we have a non-linear scale, we need to
-                    # add the margin in figure space and then
-                    # transform back
-                    minpos = getattr(bb, minpos)
-                    transform = axis.get_transform()
-                    inverse_trans = transform.inverted()
-                    x0, x1 = axis._scale.limit_range_for_scale(
-                        x0, x1, minpos)
-                    x0t, x1t = transform.transform([x0, x1])
-                    delta = (x1t - x0t) * margin
-                    if do_lower_margin:
-                        x0t -= delta
-                    if do_upper_margin:
-                        x1t += delta
-                    x0, x1 = inverse_trans.transform([x0t, x1t])
-
-            if not _tight:
+            # Add the margin in figure space and then transform back, to handle
+            # non-linear scales.
+            minpos = getattr(bb, minpos)
+            transform = axis.get_transform()
+            inverse_trans = transform.inverted()
+            do_lower_margin = x0 not in stickies
+            do_upper_margin = x1 not in stickies
+            x0, x1 = axis._scale.limit_range_for_scale(x0, x1, minpos)
+            x0t, x1t = transform.transform([x0, x1])
+            delta = (x1t - x0t) * margin
+            if do_lower_margin:
+                x0t -= delta
+            if do_upper_margin:
+                x1t += delta
+            x0, x1 = inverse_trans.transform([x0t, x1t])
+
+            if not self._tight:
                 x0, x1 = locator.view_limits(x0, x1)
             set_bound(x0, x1)
             # End of definition of internal function 'handle_single_axis'.
 
         handle_single_axis(
-            scalex, self._autoscaleXon, self._shared_x_axes,
-            'intervalx', 'minposx', self.xaxis, self._xmargin,
-            margins['left'], margins['right'], self.set_xbound)
+            scalex, self._autoscaleXon, self._shared_x_axes, 'intervalx',
+            'minposx', self.xaxis, self._xmargin, x_stickies, self.set_xbound)
         handle_single_axis(
-            scaley, self._autoscaleYon, self._shared_y_axes,
-            'intervaly', 'minposy', self.yaxis, self._ymargin,
-            margins['bottom'], margins['top'], self.set_ybound)
+            scaley, self._autoscaleYon, self._shared_y_axes, 'intervaly',
+            'minposy', self.yaxis, self._ymargin, y_stickies, self.set_ybound)
 
     def _get_axis_list(self):
         return (self.xaxis, self.yaxis)
diff --git a/lib/matplotlib/cbook.py b/lib/matplotlib/cbook.py
@@ -13,7 +13,6 @@
 from six.moves import xrange, zip
 from itertools import repeat
 import collections
-
 import datetime
 import errno
 import functools
diff --git a/lib/matplotlib/image.py b/lib/matplotlib/image.py
