Factor out common code between Patch.draw and FancyArrowPatch.draw.

anntzer · anntzer · commit f574cf218fa8 · 2018-07-24T15:25:21.000+02:00
The code setting up the renderer and gc are nearly identical, so we can
factor it out as a helper contextmanager.  The only difference is that
FancyArrowPatch then calls draw_path multiple times with various
arguments.

Note that the refactoring exposed the fact that FancyArrowPatches are
(incorrectly, IMO) ignoring joinstyles and capstyles (this is necessary
to make image test pass, but we probably will want to generate new
images with the "correct" (non-ignoring) behavior at some point).
diff --git a/lib/matplotlib/patches.py b/lib/matplotlib/patches.py
@@ -1,3 +1,4 @@
+import contextlib
 import functools
 import math
 from numbers import Number
@@ -479,11 +480,15 @@ def get_hatch(self):
         'Return the current hatching pattern'
         return self._hatch
 
-    @artist.allow_rasterization
-    def draw(self, renderer):
-        'Draw the :class:`Patch` to the given *renderer*.'
-        if not self.get_visible():
-            return
+    @contextlib.contextmanager
+    def _prepare_path_drawer(self, renderer):
+        """
+        ``draw()`` helper factored out for sharing with `FancyArrowPatch`.
+
+        Yields a callable that can be called as a bound ``draw_path`` method
+        except that the first argument (the ``GraphicsContext``) has already
+        been suitably filled in.
+        """
 
         renderer.open_group('patch', self.get_gid())
         gc = renderer.new_gc()
@@ -521,21 +526,37 @@ def draw(self, renderer):
         if self.get_sketch_params() is not None:
             gc.set_sketch_params(*self.get_sketch_params())
 
-        path = self.get_path()
-        transform = self.get_transform()
-        tpath = transform.transform_path_non_affine(path)
-        affine = transform.get_affine()
-
         if self.get_path_effects():
             from matplotlib.patheffects import PathEffectRenderer
             renderer = PathEffectRenderer(self.get_path_effects(), renderer)
 
-        renderer.draw_path(gc, tpath, affine, rgbFace)
+        # In `with _prepare_path_drawer(renderer) as draw_path: draw_path(...)`
+        # (in the implementations of `draw()` below), calls to `draw_path(...)`
+        # will occur as if they took place here with `gc` inserted as
+        # additional first argument.
+        yield functools.partial(renderer.draw_path, gc)
 
         gc.restore()
         renderer.close_group('patch')
         self.stale = False
 
+    @artist.allow_rasterization
+    def draw(self, renderer):
+        'Draw the :class:`Patch` to the given *renderer*.'
+        if not self.get_visible():
+            return
+
+        with self._prepare_path_drawer(renderer) as draw_path:
+            path = self.get_path()
+            transform = self.get_transform()
+            tpath = transform.transform_path_non_affine(path)
+            affine = transform.get_affine()
+            draw_path(tpath, affine,
+                      # Work around a bug in the PDF and SVG renderers, which
+                      # do not draw the hatches if the facecolor is fully
+                      # transparent, but do if it is None.
+                      self._facecolor if self._facecolor[3] else None)
+
     def get_path(self):
         """
         Return the path of this patch
@@ -4256,67 +4277,23 @@ def draw(self, renderer):
         if not self.get_visible():
             return
 
-        renderer.open_group('patch', self.get_gid())
-        gc = renderer.new_gc()
-
-        gc.set_foreground(self._edgecolor, isRGBA=True)
-
-        lw = self._linewidth
-        if self._edgecolor[3] == 0:
-            lw = 0
-        gc.set_linewidth(lw)
-        gc.set_dashes(self._dashoffset, self._dashes)
-
-        gc.set_antialiased(self._antialiased)
-        self._set_gc_clip(gc)
-        gc.set_capstyle('round')
-        gc.set_snap(self.get_snap())
-
-        rgbFace = self._facecolor
-        if rgbFace[3] == 0:
-            rgbFace = None  # (some?) renderers expect this as no-fill signal
-
-        gc.set_alpha(self._alpha)
-
-        if self._hatch:
-            gc.set_hatch(self._hatch)
-            if self._hatch_color is not None:
-                try:
-                    gc.set_hatch_color(self._hatch_color)
-                except AttributeError:
-                    # if we end up with a GC that does not have this method
-                    warnings.warn("Your backend does not support setting the "
-                                  "hatch color.")
-
-        if self.get_sketch_params() is not None:
-            gc.set_sketch_params(*self.get_sketch_params())
+        # FancyArrowPatch have traditionally forced the capstyle and joinstyle.
+        with cbook._setattr_cm(self, _capstyle='round', _joinstyle='round'), \
+                self._prepare_path_drawer(renderer) as draw_path:
 
-        # FIXME : dpi_cor is for the dpi-dependecy of the
-        # linewidth. There could be room for improvement.
-        #
-        # dpi_cor = renderer.points_to_pixels(1.)
-        self.set_dpi_cor(renderer.points_to_pixels(1.))
-        path, fillable = self.get_path_in_displaycoord()
+            # FIXME : dpi_cor is for the dpi-dependecy of the linewidth. There
+            # could be room for improvement.
+            self.set_dpi_cor(renderer.points_to_pixels(1.))
+            path, fillable = self.get_path_in_displaycoord()
 
-        if not cbook.iterable(fillable):
-            path = [path]
-            fillable = [fillable]
+            if not cbook.iterable(fillable):
+                path = [path]
+                fillable = [fillable]
 
-        affine = transforms.IdentityTransform()
+            affine = transforms.IdentityTransform()
 
-        if self.get_path_effects():
-            from matplotlib.patheffects import PathEffectRenderer
-            renderer = PathEffectRenderer(self.get_path_effects(), renderer)
-
-        for p, f in zip(path, fillable):
-            if f:
-                renderer.draw_path(gc, p, affine, rgbFace)
-            else:
-                renderer.draw_path(gc, p, affine, None)
-
-        gc.restore()
-        renderer.close_group('patch')
-        self.stale = False
+            for p, f in zip(path, fillable):
+                draw_path(p, affine, self._facecolor if f else None)
 
 
 class ConnectionPatch(FancyArrowPatch):
