Lazily resolve colors for Patches.

anntzer · anntzer · commit ec56a0c64457 · 2018-07-20T11:04:09.000+02:00
This is consistent with Line2Ds and avoids complications with
_original_{face,edge}color.

test_patch_color_none was removed as it doesn't make much sense anymore
(fixing it would just mean testing that mcolors.to_rgba is working as
expected).
diff --git a/doc/api/next_api_changes/2018-07-20-AL.rst b/doc/api/next_api_changes/2018-07-20-AL.rst
@@ -0,0 +1,12 @@
+Lazy color resolution for patches
+`````````````````````````````````
+
+Patches now lazily resolve colors and apply alpha at draw time, similarly
+to Line2Ds.  In particular, this means that they will be affected by later
+modifications to :rc:`patch.facecolor` and :rc:`patch.edgecolor`, and that
+``patch.get_facecolor()`` and ``patch.get_edgecolor()`` no longer necessarily
+return RGBA tuples but rather whatever was passed in with the corresponding
+setters.
+
+:rc:`hatch.color` is still resolved at artist creation time as there is no
+other way to set the hatch color.
diff --git a/lib/matplotlib/patches.py b/lib/matplotlib/patches.py
@@ -68,7 +68,6 @@ def __init__(self,
         if antialiased is None:
             antialiased = mpl.rcParams['patch.antialiased']
 
-        self._hatch_color = colors.to_rgba(mpl.rcParams['hatch.color'])
         self._fill = True  # needed for set_facecolor call
         if color is not None:
             if edgecolor is not None or facecolor is not None:
@@ -87,6 +86,7 @@ def __init__(self,
         self.set_linewidth(linewidth)
         self.set_antialiased(antialiased)
         self.set_hatch(hatch)
+        self._orig_hatch_color = colors.to_rgba(mpl.rcParams['hatch.color'])
         self.set_capstyle(capstyle)
         self.set_joinstyle(joinstyle)
         self._combined_transform = transforms.IdentityTransform()
@@ -115,7 +115,7 @@ def _process_radius(self, radius):
         if isinstance(self._picker, Number):
             _radius = self._picker
         else:
-            if self.get_edgecolor()[3] == 0:
+            if self._get_drawn_edgecolor()[3] == 0:
                 _radius = 0
             else:
                 _radius = self.get_linewidth()
@@ -170,7 +170,6 @@ def update_from(self, other):
         self._facecolor = other._facecolor
         self._fill = other._fill
         self._hatch = other._hatch
-        self._hatch_color = other._hatch_color
         # copy the unscaled dash pattern
         self._us_dashes = other._us_dashes
         self.set_linewidth(other._linewidth)  # also sets dash properties
@@ -221,13 +220,23 @@ def get_edgecolor(self):
         """
         Return the edge color of the :class:`Patch`.
         """
-        return self._edgecolor
+        ec = self._edgecolor
+        if ec is None:
+            if (mpl.rcParams['patch.force_edgecolor'] or
+                    not self._fill or self._edge_default):
+                ec = mpl.rcParams['patch.edgecolor']
+            else:
+                ec = 'none'
+        return ec
 
     def get_facecolor(self):
         """
         Return the face color of the :class:`Patch`.
         """
-        return self._facecolor
+        fc = self._facecolor
+        if fc is None:
+            fc = mpl.rcParams['patch.facecolor']
+        return fc
 
     def get_linewidth(self):
         """
@@ -254,21 +263,6 @@ def set_antialiased(self, aa):
         self._antialiased = aa
         self.stale = True
 
-    def _set_edgecolor(self, color):
-        set_hatch_color = True
-        if color is None:
-            if (mpl.rcParams['patch.force_edgecolor'] or
-                    not self._fill or self._edge_default):
-                color = mpl.rcParams['patch.edgecolor']
-            else:
-                color = 'none'
-                set_hatch_color = False
-
-        self._edgecolor = colors.to_rgba(color, self._alpha)
-        if set_hatch_color:
-            self._hatch_color = self._edgecolor
-        self.stale = True
-
     def set_edgecolor(self, color):
         """
         Set the patch edge color.
@@ -277,14 +271,7 @@ def set_edgecolor(self, color):
         ----------
         color : color or None or 'auto'
         """
-        self._original_edgecolor = color
-        self._set_edgecolor(color)
-
-    def _set_facecolor(self, color):
-        if color is None:
-            color = mpl.rcParams['patch.facecolor']
-        alpha = self._alpha if self._fill else 0
-        self._facecolor = colors.to_rgba(color, alpha)
+        self._edgecolor = color
         self.stale = True
 
     def set_facecolor(self, color):
@@ -295,8 +282,8 @@ def set_facecolor(self, color):
         ----------
         color : color or None
         """
-        self._original_facecolor = color
-        self._set_facecolor(color)
+        self._facecolor = color
+        self.stale = True
 
     def set_color(self, c):
         """
@@ -314,24 +301,6 @@ def set_color(self, c):
         self.set_facecolor(c)
         self.set_edgecolor(c)
 
-    def set_alpha(self, alpha):
-        """
-        Set the alpha transparency of the patch.
-
-        Parameters
-        ----------
-        alpha : float or None
-        """
-        if alpha is not None:
-            try:
-                float(alpha)
-            except TypeError:
-                raise TypeError('alpha must be a float or None')
-        artist.Artist.set_alpha(self, alpha)
-        self._set_facecolor(self._original_facecolor)
-        self._set_edgecolor(self._original_edgecolor)
-        # stale is already True
-
     def set_linewidth(self, w):
         """
         Set the patch linewidth in points
@@ -393,8 +362,7 @@ def set_fill(self, b):
         b : bool
         """
         self._fill = bool(b)
-        self._set_facecolor(self._original_facecolor)
-        self._set_edgecolor(self._original_edgecolor)
+        self.set_edgecolor(self._edgecolor)
         self.stale = True
 
     def get_fill(self):
@@ -479,6 +447,24 @@ def get_hatch(self):
         'Return the current hatching pattern'
         return self._hatch
 
+    def _get_drawn_edgecolor(self):
+        return colors.to_rgba(self.get_edgecolor(), self._alpha)
+
+    def _get_drawn_facecolor(self):
+        return colors.to_rgba(self.get_facecolor(),
+                              self._alpha if self._fill else 0)
+
+    def _get_drawn_hatchcolor(self):
+        hc = self._edgecolor
+        if hc is None:
+            if (mpl.rcParams['patch.force_edgecolor'] or
+                    not self._fill or self._edge_default):
+                hc = mpl.rcParams['patch.edgecolor']
+            else:
+                # Not affected by alpha.
+                return self._orig_hatch_color
+        return colors.to_rgba(hc, self._alpha)
+
     @artist.allow_rasterization
     def draw(self, renderer):
         'Draw the :class:`Patch` to the given *renderer*.'
@@ -488,10 +474,11 @@ def draw(self, renderer):
         renderer.open_group('patch', self.get_gid())
         gc = renderer.new_gc()
 
-        gc.set_foreground(self._edgecolor, isRGBA=True)
+        edgecolor = self._get_drawn_edgecolor()
+        gc.set_foreground(edgecolor, isRGBA=True)
 
         lw = self._linewidth
-        if self._edgecolor[3] == 0:
+        if edgecolor[3] == 0:
             lw = 0
         gc.set_linewidth(lw)
         gc.set_dashes(0, self._dashes)
@@ -503,7 +490,7 @@ def draw(self, renderer):
         gc.set_url(self._url)
         gc.set_snap(self.get_snap())
 
-        rgbFace = self._facecolor
+        rgbFace = self._get_drawn_facecolor()
         if rgbFace[3] == 0:
             rgbFace = None  # (some?) renderers expect this as no-fill signal
 
@@ -512,7 +499,7 @@ def draw(self, renderer):
         if self._hatch:
             gc.set_hatch(self._hatch)
             try:
-                gc.set_hatch_color(self._hatch_color)
+                gc.set_hatch_color(self._get_drawn_hatchcolor())
             except AttributeError:
                 # if we end up with a GC that does not have this method
                 warnings.warn(
@@ -4259,10 +4246,11 @@ def draw(self, renderer):
         renderer.open_group('patch', self.get_gid())
         gc = renderer.new_gc()
 
-        gc.set_foreground(self._edgecolor, isRGBA=True)
+        edgecolor = self._get_drawn_edgecolor()
+        gc.set_foreground(edgecolor, isRGBA=True)
 
         lw = self._linewidth
-        if self._edgecolor[3] == 0:
+        if edgecolor[3] == 0:
             lw = 0
         gc.set_linewidth(lw)
         gc.set_dashes(self._dashoffset, self._dashes)
@@ -4272,7 +4260,7 @@ def draw(self, renderer):
         gc.set_capstyle('round')
         gc.set_snap(self.get_snap())
 
-        rgbFace = self._facecolor
+        rgbFace = self._get_drawn_facecolor()
         if rgbFace[3] == 0:
             rgbFace = None  # (some?) renderers expect this as no-fill signal
 
@@ -4282,7 +4270,7 @@ def draw(self, renderer):
             gc.set_hatch(self._hatch)
             if self._hatch_color is not None:
                 try:
-                    gc.set_hatch_color(self._hatch_color)
+                    gc.set_hatch_color(self._get_drawn_hatchcolor())
                 except AttributeError:
                     # if we end up with a GC that does not have this method
                     warnings.warn("Your backend does not support setting the "
diff --git a/lib/matplotlib/tests/test_axes.py b/lib/matplotlib/tests/test_axes.py
@@ -1461,16 +1461,16 @@ def test_bar_color_none_alpha():
     ax = plt.gca()
     rects = ax.bar([1, 2], [2, 4], alpha=0.3, color='none', edgecolor='r')
     for rect in rects:
-        assert rect.get_facecolor() == (0, 0, 0, 0)
-        assert rect.get_edgecolor() == (1, 0, 0, 0.3)
+        assert rect._get_drawn_facecolor() == (0, 0, 0, 0)
+        assert rect._get_drawn_edgecolor() == (1, 0, 0, 0.3)
 
 
 def test_bar_edgecolor_none_alpha():
     ax = plt.gca()
     rects = ax.bar([1, 2], [2, 4], alpha=0.3, color='r', edgecolor='none')
     for rect in rects:
-        assert rect.get_facecolor() == (1, 0, 0, 0.3)
-        assert rect.get_edgecolor() == (0, 0, 0, 0)
+        assert rect._get_drawn_facecolor() == (1, 0, 0, 0.3)
+        assert rect._get_drawn_edgecolor() == (0, 0, 0, 0)
 
 
 @image_comparison(baseline_images=['barh_tick_label'],
@@ -5659,7 +5659,8 @@ def test_bar_broadcast_args():
     ax.bar(0, 1, bottom=range(4), width=1, orientation='horizontal')
     # Check that edgecolor gets broadcasted.
     rect1, rect2 = ax.bar([0, 1], [0, 1], edgecolor=(.1, .2, .3, .4))
-    assert rect1.get_edgecolor() == rect2.get_edgecolor() == (.1, .2, .3, .4)
+    assert rect1._get_drawn_edgecolor() == rect2._get_drawn_edgecolor() \
+        == (.1, .2, .3, .4)
 
 
 def test_invalid_axis_limits():
diff --git a/lib/matplotlib/tests/test_legend.py b/lib/matplotlib/tests/test_legend.py
@@ -9,10 +9,11 @@
 from matplotlib.testing.decorators import image_comparison
 import matplotlib.pyplot as plt
 import matplotlib as mpl
-import matplotlib.transforms as mtransforms
 import matplotlib.collections as mcollections
-from matplotlib.legend_handler import HandlerTuple
+import matplotlib.colors as mcolors
 import matplotlib.legend as mlegend
+from matplotlib.legend_handler import HandlerTuple
+import matplotlib.transforms as mtransforms
 from matplotlib.cbook.deprecation import MatplotlibDeprecationWarning
 
 
@@ -543,3 +544,14 @@ def test_draggable():
     with pytest.warns(MatplotlibDeprecationWarning):
         legend.draggable()
     assert not legend.get_draggable()
+
+
+def test_alpha_handles():
+    x, n, hh = plt.hist([1, 2, 3], alpha=0.25, label='data', color='red')
+    legend = plt.legend()
+    for lh in legend.legendHandles:
+        lh.set_alpha(1.0)
+    assert mcolors.to_rgb(lh.get_facecolor()) \
+        == mcolors.to_rgb(hh[1].get_facecolor())
+    assert mcolors.to_rgb(lh.get_edgecolor()) \
+        == mcolors.to_rgb(hh[1].get_edgecolor())
diff --git a/lib/matplotlib/tests/test_patches.py b/lib/matplotlib/tests/test_patches.py
@@ -176,14 +176,6 @@ def test_patch_alpha_override():
     ax.set_ylim([-1, 2])
 
 
-@pytest.mark.style('default')
-def test_patch_color_none():
-    # Make sure the alpha kwarg does not override 'none' facecolor.
-    # Addresses issue #7478.
-    c = plt.Circle((0, 0), 1, facecolor='none', alpha=1)
-    assert c.get_facecolor()[0] == 0
-
-
 @image_comparison(baseline_images=['patch_custom_linestyle'],
                   remove_text=True)
 def test_patch_custom_linestyle():
diff --git a/lib/matplotlib/tests/test_rcparams.py b/lib/matplotlib/tests/test_rcparams.py
@@ -172,7 +172,7 @@ def test_legend_colors(color_type, param_dict, target):
         _, ax = plt.subplots()
         ax.plot(range(3), label='test')
         leg = ax.legend()
-        assert getattr(leg.legendPatch, get_func)() == target
+        assert mcolors.same_color(getattr(leg.legendPatch, get_func)(), target)
 
 
 def test_mfc_rcparams():
