implement path_effects for Line2D objects

Author: leejjoon

lib/matplotlib/lines.py

@@ -149,6 +149,7 @@ def __init__(self, xdata, ydata,
                  pickradius=5,
                  drawstyle=None,
                  markevery=None,
+                 path_effects = None,
                  **kwargs
                  ):
         """
@@ -236,6 +237,8 @@ def __init__(self, xdata, ydata,
         self._invalidy = True
         self.set_data(xdata, ydata)
 
+        self.set_path_effects(path_effects)
+
     def contains(self, mouseevent):
         """
         Test whether the mouse event occurred on the line.  The pick
@@ -550,7 +553,14 @@ def draw(self, renderer):
                 self._lineFunc = getattr(self, funcname)
                 funcname = self.drawStyles.get(self._drawstyle, '_draw_lines')
                 drawFunc = getattr(self, funcname)
-                drawFunc(renderer, gc, tpath, affine.frozen())
+
+                if self.get_path_effects():
+                    affine_frozen = affine.frozen()
+                    for pe in self.get_path_effects():
+                        pe_renderer = pe.get_proxy_renderer(renderer)
+                        drawFunc(pe_renderer, gc, tpath, affine_frozen)
+                else:
+                    drawFunc(renderer, gc, tpath, affine.frozen())
 
         if self._marker:
             gc = renderer.new_gc()
@@ -600,18 +610,34 @@ def draw(self, renderer):
                     gc.set_linewidth(0)
                 if rgbaFace is not None:
                     gc.set_alpha(rgbaFace[3])
-                renderer.draw_markers(
-                    gc, marker_path, marker_trans, subsampled, affine.frozen(),
-                    rgbaFace)
+
+                if self.get_path_effects():
+                    affine_frozen = affine.frozen()
+                    for pe in self.get_path_effects():
+                        pe.draw_markers(renderer, gc, marker_path, marker_trans,
+                                        subsampled, affine_frozen, rgbaFace)
+                else:
+                    renderer.draw_markers(
+                        gc, marker_path, marker_trans, subsampled, affine.frozen(),
+                        rgbaFace)
+
                 alt_marker_path = marker.get_alt_path()
                 if alt_marker_path:
                     if rgbaFaceAlt is not None:
                         gc.set_alpha(rgbaFaceAlt[3])
                     alt_marker_trans = marker.get_alt_transform()
                     alt_marker_trans = alt_marker_trans.scale(w)
-                    renderer.draw_markers(
-                        gc, alt_marker_path, alt_marker_trans, subsampled,
-                        affine.frozen(), rgbaFaceAlt)
+
+                    if self.get_path_effects():
+                        affine_frozen = affine.frozen()
+                        for pe in self.get_path_effects():
+                            pe.draw_markers(renderer, gc, alt_marker_path,
+                                            alt_marker_trans, subsampled,
+                                            affine_frozen, rgbaFaceAlt)
+                    else:
+                        renderer.draw_markers(
+                            gc, alt_marker_path, alt_marker_trans, subsampled,
+                            affine.frozen(), rgbaFaceAlt)
 
             gc.restore()
 
@@ -1161,6 +1187,16 @@ def is_dashed(self):
         'return True if line is dashstyle'
         return self._linestyle in ('--', '-.', ':')
 
+    def set_path_effects(self, path_effects):
+        """
+        set path_effects, which should be a list of instances of
+        matplotlib.patheffect._Base class or its derivatives.
+        """
+        self._path_effects = path_effects
+
+    def get_path_effects(self):
+        return self._path_effects
+
 
 class VertexSelector:
     """

lib/matplotlib/patheffects.py

@@ -10,7 +10,6 @@
 import matplotlib.transforms as transforms
 
 
-
 class _Base(object):
     """
     A base class for PathEffect. Derived must override draw_path method.
@@ -22,6 +21,9 @@ def __init__(self):
         """
         super(_Base, self).__init__()
 
+    def get_proxy_renderer(self, renderer):
+        pe_renderer = ProxyRenderer(self, renderer)
+        return pe_renderer
 
     def _update_gc(self, gc, new_gc_dict):
         new_gc_dict = new_gc_dict.copy()
@@ -39,7 +41,7 @@ def _update_gc(self, gc, new_gc_dict):
         return gc
 
 
-    def draw_path(self, renderer, gc, tpath, affine, rgbFace):
+    def draw_path(self, renderer, gc, tpath, affine, rgbFace=None):
         """
         Derived should override this method. The argument is same
         as *draw_path* method of :class:`matplotlib.backend_bases.RendererBase`
@@ -71,6 +73,33 @@ def _draw_text_as_path(self, renderer, gc, x, y, s, prop, angle, ismath):
         gc.set_linewidth(0.0)
         self.draw_path(renderer, gc, path, transform, rgbFace=color)
 
+    def draw_markers(self, renderer, gc, marker_path, marker_trans, path, trans, rgbFace=None):
+        """
+        Draws a marker at each of the vertices in path.  This includes
+        all vertices, including control points on curves.  To avoid
+        that behavior, those vertices should be removed before calling
+        this function.
+
+        *gc*
+            the :class:`GraphicsContextBase` instance
+
+        *marker_trans*
+            is an affine transform applied to the marker.
+
+        *trans*
+             is an affine transform applied to the path.
+
+        This provides a fallback implementation of draw_markers that
+        makes multiple calls to :meth:`draw_path`.  Some backends may
+        want to override this method in order to draw the marker only
+        once and reuse it multiple times.
+        """
+        for vertices, codes in path.iter_segments(trans, simplify=False):
+            if len(vertices):
+                x,y = vertices[-2:]
+                self.draw_path(renderer, gc, marker_path,
+                               marker_trans + transforms.Affine2D().translate(x, y),
+                               rgbFace)
 
 #     def draw_path_collection(self, renderer,
 #                              gc, master_transform, paths, all_transforms,
@@ -88,6 +117,27 @@ def _draw_text_as_path(self, renderer, gc, x, y, s, prop, angle, ismath):
 #             transform = transforms.Affine2D(transform.get_matrix()).translate(xo, yo)
 #             self.draw_path(renderer, gc0, path, transform, rgbFace)
 
+class ProxyRenderer(object):
+    def __init__(self, path_effect, renderer):
+        self._path_effect = path_effect
+        self._renderer = renderer
+
+    def draw_path(self, gc, tpath, affine, rgbFace=None):
+        self._path_effect.draw_path(self._renderer, gc, tpath, affine, rgbFace)
+
+    def draw_tex(self, gc, x, y, s, prop, angle, ismath='TeX!'):
+        self._path_effect._draw_text_as_path(self._renderer,
+                                             gc, x, y, s, prop, angle, ismath="TeX")
+
+    def draw_text(self, gc, x, y, s, prop, angle, ismath=False):
+        self._path_effect._draw_text(self.renderer,
+                                     gc, x, y, s, prop, angle, ismath)
+
+    def draw_markers(self, gc, marker_path, marker_trans, path, trans, rgbFace=None):
+        self._path_effect.draw_markers(self._renderer,
+                                       gc, marker_path, marker_trans, path, trans,
+                                       rgbFace=rgbFace)
+
 
 class Normal(_Base):
     """