Merge remote-tracking branch 'matplotlib/v2.x'

Conflicts:
	examples/showcase/anatomy.py
	   White space conflict

Author: tacaswell

doc/faq/anatomy.png

@@ -625,6 +625,11 @@ The behavior of the PS and Agg backends was DPI dependent, thus::
 
 There is no API level control of the hatch color or linewidth.
 
+Hatching patterns are now rendered at a consistent density, regardless of DPI.
+Formerly, high DPI figures would be more dense than the default, and low DPI
+figures would be less dense.  This old behavior cannot be directly restored,
+but the density may be increased by repeating the hatch specifier.
+
 
 .. _default_changes_font:
 

doc/users/dflt_style_changes.rst

@@ -2,7 +2,7 @@
 
 import numpy as np
 import matplotlib.pyplot as plt
-from matplotlib.ticker import MultipleLocator, FuncFormatter
+from matplotlib.ticker import AutoMinorLocator, MultipleLocator, FuncFormatter
 
 np.random.seed(19680801)
 
@@ -11,7 +11,7 @@
 Y2 = 1+np.cos(1+X/0.75)/2
 Y3 = np.random.uniform(Y1, Y2, len(X))
 
-fig = plt.figure(figsize=(8, 8), facecolor="w")
+fig = plt.figure(figsize=(8, 8))
 ax = fig.add_subplot(1, 1, 1, aspect=1)
 
 
@@ -21,9 +21,9 @@ def minor_tick(x, pos):
     return "%.2f" % x
 
 ax.xaxis.set_major_locator(MultipleLocator(1.000))
-ax.xaxis.set_minor_locator(MultipleLocator(0.250))
+ax.xaxis.set_minor_locator(AutoMinorLocator(4))
 ax.yaxis.set_major_locator(MultipleLocator(1.000))
-ax.yaxis.set_minor_locator(MultipleLocator(0.250))
+ax.yaxis.set_minor_locator(AutoMinorLocator(4))
 ax.xaxis.set_minor_formatter(FuncFormatter(minor_tick))
 
 ax.set_xlim(0, 4)
@@ -38,13 +38,14 @@ def minor_tick(x, pos):
 
 ax.plot(X, Y1, c=(0.25, 0.25, 1.00), lw=2, label="Blue signal", zorder=10)
 ax.plot(X, Y2, c=(1.00, 0.25, 0.25), lw=2, label="Red signal")
-ax.scatter(X, Y3, c='w')
+ax.plot(X, Y3, linewidth=0,
+        marker='o', markerfacecolor='w', markeredgecolor='k')
 
-ax.set_title("Anatomy of a figure", fontsize=20)
+ax.set_title("Anatomy of a figure", fontsize=20, verticalalignment='bottom')
 ax.set_xlabel("X axis label")
 ax.set_ylabel("Y axis label")
 
-ax.legend(frameon=False)
+ax.legend()
 
 
 def circle(x, y, radius=0.15):
@@ -62,32 +63,32 @@ def text(x, y, text):
 
 
 # Minor tick
-circle(0.50, -.05)
-text(0.50, -0.25, "Minor tick label")
+circle(0.50, -0.10)
+text(0.50, -0.32, "Minor tick label")
 
 # Major tick
-circle(4.00, 2.00)
-text(4.00, 1.80, "Major tick")
+circle(-0.03, 4.00)
+text(0.03, 3.80, "Major tick")
 
 # Minor tick
-circle(0.25, 4.00)
-text(0.25, 3.80, "Minor tick")
+circle(0.00, 3.50)
+text(0.00, 3.30, "Minor tick")
 
 # Major tick label
-circle(-0.05, 3.00)
-text(-0.05, 2.80, "Major tick label")
+circle(-0.15, 3.00)
+text(-0.15, 2.80, "Major tick label")
 
 # X Label
-circle(1.80, -0.22)
-text(1.80, -0.4, "X axis label")
+circle(1.80, -0.27)
+text(1.80, -0.45, "X axis label")
 
 # Y Label
-circle(-0.20, 1.80)
-text(-0.20, 1.6, "Y axis label")
+circle(-0.27, 1.80)
+text(-0.27, 1.6, "Y axis label")
 
 # Title
-circle(1.60, 4.10)
-text(1.60, 3.9, "Title")
+circle(1.60, 4.13)
+text(1.60, 3.93, "Title")
 
 # Blue plot
 circle(1.75, 2.80)
@@ -106,8 +107,8 @@ def text(x, y, text):
 text(3.00, 2.80, "Grid")
 
 # Legend
-circle(3.70, 3.75)
-text(3.70, 3.55, "Legend")
+circle(3.70, 3.80)
+text(3.70, 3.60, "Legend")
 
 # Axes
 circle(0.5, 0.5)

examples/showcase/anatomy.py

@@ -2173,6 +2173,10 @@ def autoscale(self, enable=True, axis='both', tight=None):
             if axis in ['y', 'both']:
                 self._autoscaleYon = bool(enable)
                 scaley = self._autoscaleYon
+        if tight and scalex:
+            self._xmargin = 0
+        if tight and scaley:
+            self._ymargin = 0
         self.autoscale_view(tight=tight, scalex=scalex, scaley=scaley)
 
     def autoscale_view(self, tight=None, scalex=True, scaley=True):
@@ -2182,6 +2186,14 @@ def autoscale_view(self, tight=None, scalex=True, scaley=True):
         setting *scaley* to *False*.  The autoscaling preserves any
         axis direction reversal that has already been done.
 
+        If *tight* is *False*, the axis major locator will be used
+        to expand the view limits if rcParams['axes.autolimit_mode']
+        is 'round_numbers'.  Note that any margins that are in effect
+        will be applied first, regardless of whether *tight* is
+        *True* or *False*.  Specifying *tight* as *True* or *False*
+        saves the setting as a private attribute of the Axes; specifying
+        it as *None* (the default) applies the previously saved value.
+
         The data limits are not updated automatically when artist data are
         changed after the artist has been added to an Axes instance.  In that
         case, use :meth:`matplotlib.axes.Axes.relim` prior to calling
@@ -2234,52 +2246,56 @@ def autoscale_view(self, tight=None, scalex=True, scaley=True):
         def handle_single_axis(scale, autoscaleon, shared_axes, interval,
                                minpos, axis, margin, do_lower_margin,
                                do_upper_margin, set_bound):
-            if scale and autoscaleon:
-                shared = shared_axes.get_siblings(self)
-                dl = [ax.dataLim for ax in shared]
-                # ignore non-finite data limits if good limits exist
-                finite_dl = [d for d in dl if np.isfinite(d).all()]
-                if len(finite_dl):
-                    dl = finite_dl
-
-                bb = mtransforms.BboxBase.union(dl)
-                x0, x1 = getattr(bb, interval)
-                locator = axis.get_major_locator()
-                try:
-                    # e.g., DateLocator has its own nonsingular()
-                    x0, x1 = locator.nonsingular(x0, x1)
-                except AttributeError:
-                    # Default nonsingular for, e.g., MaxNLocator
-                    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:
-                    x0, x1 = locator.view_limits(x0, x1)
-                set_bound(x0, x1)
+
+            if not (scale and autoscaleon):
+                return  # nothing to do...
+
+            shared = shared_axes.get_siblings(self)
+            dl = [ax.dataLim for ax in shared]
+            # ignore non-finite data limits if good limits exist
+            finite_dl = [d for d in dl if np.isfinite(d).all()]
+            if len(finite_dl):
+                dl = finite_dl
+
+            bb = mtransforms.BboxBase.union(dl)
+            x0, x1 = getattr(bb, interval)
+            locator = axis.get_major_locator()
+            try:
+                # e.g., DateLocator has its own nonsingular()
+                x0, x1 = locator.nonsingular(x0, x1)
+            except AttributeError:
+                # Default nonsingular for, e.g., MaxNLocator
+                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:
+                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,

lib/matplotlib/axes/_base.py

@@ -1152,12 +1152,12 @@ def alphaState(self, alpha):
     def hatchPattern(self, hatch_style):
         # The colors may come in as numpy arrays, which aren't hashable
         if hatch_style is not None:
-            face, edge, hatch = hatch_style
-            if face is not None:
-                face = tuple(face)
+            edge, face, hatch = hatch_style
             if edge is not None:
                 edge = tuple(edge)
-            hatch_style = (face, edge, hatch)
+            if face is not None:
+                face = tuple(face)
+            hatch_style = (edge, face, hatch)
 
         pattern = self.hatchPatterns.get(hatch_style, None)
         if pattern is not None:
@@ -1182,7 +1182,9 @@ def writeHatches(self):
                  'PatternType': 1, 'PaintType': 1, 'TilingType': 1,
                  'BBox': [0, 0, sidelen, sidelen],
                  'XStep': sidelen, 'YStep': sidelen,
-                 'Resources': res})
+                 'Resources': res,
+                 # Change origin to match Agg at top-left.
+                 'Matrix': [1, 0, 0, 1, 0, self.height * 72]})
 
             stroke_rgb, fill_rgb, path = hatch_style
             self.output(stroke_rgb[0], stroke_rgb[1], stroke_rgb[2],
@@ -1195,13 +1197,11 @@ def writeHatches(self):
 
             self.output(rcParams['hatch.linewidth'], Op.setlinewidth)
 
-            # TODO: We could make this dpi-dependent, but that would be
-            # an API change
             self.output(*self.pathOperations(
                 Path.hatch(path),
                 Affine2D().scale(sidelen),
                 simplify=False))
-            self.output(Op.stroke)
+            self.output(Op.fill_stroke)
 
             self.endStream()
         self.writeObject(self.hatchObject, hatchDict)

lib/matplotlib/backends/backend_pdf.py

@@ -298,6 +298,7 @@ def create_hatch(self, hatch):
             return self._hatches[hatch]
         name = 'H%d' % len(self._hatches)
         linewidth = rcParams['hatch.linewidth']
+        pageheight = self.height * 72
         self._pswriter.write("""\
   << /PatternType 1
      /PaintType 2
@@ -311,13 +312,15 @@ def create_hatch(self, hatch):
         %(linewidth)f setlinewidth
 """ % locals())
         self._pswriter.write(
-            self._convert_path(Path.hatch(hatch), Affine2D().scale(72.0),
+            self._convert_path(Path.hatch(hatch), Affine2D().scale(sidelen),
                                simplify=False))
         self._pswriter.write("""\
-          stroke
+        fill
+        stroke
      } bind
    >>
    matrix
+   0.0 %(pageheight)f translate
    makepattern
    /%(name)s exch def
 """ % locals())
@@ -854,6 +857,7 @@ def _draw_ps(self, ps, gc, rgbFace, fill=True, stroke=True, command=None):
         stroke = stroke and mightstroke
         fill = (fill and rgbFace is not None and
                 (len(rgbFace) <= 3 or rgbFace[3] != 0.0))
+        hatch = gc.get_hatch()
 
         if mightstroke:
             self.set_linewidth(gc.get_linewidth())
@@ -879,19 +883,18 @@ def _draw_ps(self, ps, gc, rgbFace, fill=True, stroke=True, command=None):
         write("\n")
 
         if fill:
-            if stroke:
+            if stroke or hatch:
                 write("gsave\n")
             self.set_color(store=0, *rgbFace[:3])
             write("fill\n")
-            if stroke:
+            if stroke or hatch:
                 write("grestore\n")
 
-        hatch = gc.get_hatch()
         if hatch:
             hatch_name = self.create_hatch(hatch)
             write("gsave\n")
-            write("[/Pattern [/DeviceRGB]] setcolorspace %f %f %f " % gc.get_hatch_color()[:3])
-            write("%s setcolor fill grestore\n" % hatch_name)
+            write("%f %f %f " % gc.get_hatch_color()[:3])
+            write("%s setpattern fill grestore\n" % hatch_name)
 
         if stroke:
             write("stroke\n")

lib/matplotlib/backends/backend_ps.py

@@ -165,6 +165,16 @@ def test_autoscale_tiny_range():
         ax[i].plot([0, 1], [1, 1 + y1])
 
 
+@cleanup(style='default')
+def test_autoscale_tight():
+    fig, ax = plt.subplots(1, 1)
+    ax.plot([1, 2, 3, 4])
+    ax.autoscale(enable=True, axis='x', tight=False)
+    ax.autoscale(enable=True, axis='y', tight=True)
+    assert_allclose(ax.get_xlim(), (-0.15, 3.15))
+    assert_allclose(ax.get_ylim(), (1.0, 4.0))
+
+
 @image_comparison(baseline_images=['offset_points'],
                   remove_text=True)
 def test_basic_annotate():

lib/matplotlib/tests/baseline_images/test_artist/clip_path_clipping.png

@@ -58,11 +58,14 @@ RendererAgg::RendererAgg(unsigned int width, unsigned int height, double dpi)
     rendererBase.clear(_fill_color);
     rendererAA.attach(rendererBase);
     rendererBin.attach(rendererBase);
-    hatchRenderingBuffer.attach(hatchBuffer, HATCH_SIZE, HATCH_SIZE, HATCH_SIZE * 4);
+    hatch_size = int(dpi);
+    hatchBuffer = new agg::int8u[hatch_size * hatch_size * 4];
+    hatchRenderingBuffer.attach(hatchBuffer, hatch_size, hatch_size, hatch_size * 4);
 }
 
 RendererAgg::~RendererAgg()
 {
+    delete[] hatchBuffer;
     delete[] alphaBuffer;
     delete[] pixBuffer;
 }