When drawing markers, don't set the GraphicsContext alpha.

Setting the alpha value on the GraphicsContext forcefully applies it to
both the edgecolor and the facecolor, *except* that a facecolor of
`None` ignores the alpha.

Instead of requiring this behavior (which needlessly complicates the
implementation of new rendering backends), the alpha value (if any) can
directly be preapplied to the edgecolor and facecolor, the edgecolor can
be applied using gc.set_foreground, and the alpha value never set on the
GraphicsContext.

Author: anntzer

lib/matplotlib/backends/backend_ps.py

@@ -536,7 +536,10 @@ def draw_markers(
         ps_cmd = ['/o {', 'gsave', 'newpath', 'translate'] # don't want the translate to be global
 
         lw = gc.get_linewidth()
-        stroke = lw != 0.0
+        alpha = (gc.get_alpha()
+                 if gc.get_forced_alpha() or len(gc.get_rgb()) == 3
+                 else gc.get_rgb()[3])
+        stroke = lw > 0 and alpha > 0
         if stroke:
             ps_cmd.append('%.1f setlinewidth' % lw)
             jint = gc.get_joinstyle()

lib/matplotlib/lines.py

@@ -759,9 +759,8 @@ def draw(self, renderer):
                 gc = renderer.new_gc()
                 self._set_gc_clip(gc)
 
-                ln_color_rgba = self._get_rgba_ln_color()
-                gc.set_foreground(ln_color_rgba, isRGBA=True)
-                gc.set_alpha(ln_color_rgba[3])
+                lc_rgba = mcolors.to_rgba(self._color, self._alpha)
+                gc.set_foreground(lc_rgba, isRGBA=True)
 
                 gc.set_antialiased(self._antialiased)
                 gc.set_linewidth(self._linewidth)
@@ -785,24 +784,23 @@ def draw(self, renderer):
         if self._marker and self._markersize > 0:
             gc = renderer.new_gc()
             self._set_gc_clip(gc)
-            rgbaFace = self._get_rgba_face()
-            rgbaFaceAlt = self._get_rgba_face(alt=True)
-            edgecolor = self.get_markeredgecolor()
-            if cbook._str_lower_equal(edgecolor, "none"):
-                gc.set_linewidth(0)
-                gc.set_foreground(rgbaFace, isRGBA=True)
-            else:
-                gc.set_foreground(edgecolor)
-                gc.set_linewidth(self._markeredgewidth)
-                mec = self._markeredgecolor
-                if (cbook._str_equal(mec, "auto")
-                        and not cbook._str_lower_equal(
-                            self.get_markerfacecolor(), "none")):
-                    gc.set_alpha(rgbaFace[3])
-                else:
-                    gc.set_alpha(self.get_alpha())
+            gc.set_linewidth(self._markeredgewidth)
             gc.set_antialiased(self._antialiased)
 
+            ec_rgba = mcolors.to_rgba(
+                self.get_markeredgecolor(), self._alpha)
+            fc_rgba = mcolors.to_rgba(
+                self._get_markerfacecolor(), self._alpha)
+            fcalt_rgba = mcolors.to_rgba(
+                self._get_markerfacecolor(alt=True), self._alpha)
+            # If the edgecolor is "auto", it is set according to the *line*
+            # color but inherits the alpha value of the *face* color, if any.
+            if (cbook._str_equal(self._markeredgecolor, "auto")
+                    and not cbook._str_lower_equal(
+                        self.get_markerfacecolor(), "none")):
+                ec_rgba = ec_rgba[:3] + (fc_rgba[3],)
+            gc.set_foreground(ec_rgba, isRGBA=True)
+
             marker = self._marker
             tpath, affine = transf_path.get_transformed_points_and_affine()
             if len(tpath.vertices):
@@ -832,22 +830,15 @@ def draw(self, renderer):
 
                 renderer.draw_markers(gc, marker_path, marker_trans,
                                       subsampled, affine.frozen(),
-                                      rgbaFace)
+                                      fc_rgba)
 
                 alt_marker_path = marker.get_alt_path()
                 if alt_marker_path:
                     alt_marker_trans = marker.get_alt_transform()
                     alt_marker_trans = alt_marker_trans.scale(w)
-                    if (cbook._str_equal(mec, "auto")
-                            and not cbook._str_lower_equal(
-                                self.get_markerfacecoloralt(), "none")):
-                        gc.set_alpha(rgbaFaceAlt[3])
-                    else:
-                        gc.set_alpha(self.get_alpha())
-
                     renderer.draw_markers(
                             gc, alt_marker_path, alt_marker_trans, subsampled,
-                            affine.frozen(), rgbaFaceAlt)
+                            affine.frozen(), fcalt_rgba)
 
             gc.restore()
 
@@ -892,8 +883,7 @@ def _get_markerfacecolor(self, alt=False):
             fc = self._markerfacecoloralt
         else:
             fc = self._markerfacecolor
-
-        if (isinstance(fc, six.string_types) and fc.lower() == 'auto'):
+        if cbook._str_lower_equal(fc, 'auto'):
             if self.get_fillstyle() == 'none':
                 return 'none'
             else:
@@ -1253,9 +1243,6 @@ def update_from(self, other):
     def _get_rgba_face(self, alt=False):
         return mcolors.to_rgba(self._get_markerfacecolor(alt=alt), self._alpha)
 
-    def _get_rgba_ln_color(self, alt=False):
-        return mcolors.to_rgba(self._color, self._alpha)
-
     def set_dash_joinstyle(self, s):
         """
         Set the join style for dashed linestyles