ENH : add dirty flag

tacaswell · tacaswell · commit f9ac8d06a0c9 · 2015-05-25T00:49:40.000-04:00
First pass at adding awareness of 'dirty' state to the draw tree.

Changing properties of an artist (as indicated by a call to
`self.pchanged()`) will make that artists axes and figure as 'dirty'.
The state of the figure is queried by the `Gcf.draw_all` to only re-draw
figure that are dirty.  This is a major performance gain for expensive
to draw figures.

This is also (maybe) setting the stage for partial re-draws.
diff --git a/lib/matplotlib/_pylab_helpers.py b/lib/matplotlib/_pylab_helpers.py
@@ -147,6 +147,7 @@ def draw_all(cls):
         """
         for f_mgr in cls.get_all_fig_managers():
             # TODO add logic to check if figure is dirty
-            f_mgr.canvas.draw()
+            if f_mgr.canvas.figure.dirty:
+                f_mgr.canvas.draw()
 
 atexit.register(Gcf.destroy_all)
diff --git a/lib/matplotlib/artist.py b/lib/matplotlib/artist.py
@@ -68,6 +68,14 @@ def draw_wrapper(artist, renderer, *args, **kwargs):
     return draw_wrapper
 
 
+def _dirty_figure_callback(self):
+    self.figure.dirty = True
+
+
+def _dirty_axes_callback(self):
+    self.axes.dirty = True
+
+
 class Artist(object):
     """
     Abstract base class for someone who renders into a
@@ -109,6 +117,7 @@ def __init__(self):
         self._snap = None
         self._sketch = rcParams['path.sketch']
         self._path_effects = rcParams['path.effects']
+        self._dirty = True
 
     def __getstate__(self):
         d = self.__dict__.copy()
@@ -210,9 +219,33 @@ def axes(self, new_axes):
                              "probably trying to re-use an artist "
                              "in more than one Axes which is not "
                              "supported")
+
         self._axes = new_axes
+        if new_axes is not None and new_axes is not self:
+            self.add_callback(_dirty_axes_callback)
+
         return new_axes
 
+    @property
+    def dirty(self):
+        """
+        If the artist is 'dirty' and needs to be re-drawn for the output to
+        match the internal state of the artist.
+        """
+        return self._dirty
+
+    @dirty.setter
+    def dirty(self, val):
+        # only trigger call-back stack on being marked as 'dirty'
+        # when not already dirty
+        # the draw process will take care of propagating the cleaning
+        # process
+        if not (self._dirty == val):
+            self._dirty = val
+            # only trigger propagation if marking as dirty
+            if self._dirty:
+                self.pchanged()
+
     def get_window_extent(self, renderer):
         """
         Get the axes bounding box in display space.
@@ -572,6 +605,7 @@ def set_figure(self, fig):
         ACCEPTS: a :class:`matplotlib.figure.Figure` instance
         """
         self.figure = fig
+        self.add_callback(_dirty_figure_callback)
         self.pchanged()
 
     def set_clip_box(self, clipbox):
@@ -728,6 +762,7 @@ def draw(self, renderer, *args, **kwargs):
         'Derived classes drawing method'
         if not self.get_visible():
             return
+        self._dirty = False
 
     def set_alpha(self, alpha):
         """
diff --git a/lib/matplotlib/axes/_base.py b/lib/matplotlib/axes/_base.py
@@ -2064,6 +2064,7 @@ def draw(self, renderer=None, inframe=False):
         # will draw the edges
         if self.axison and self._frameon:
             self.patch.draw(renderer)
+            self.patch.dirty = False
 
         if _do_composite:
             # make a composite image, blending alpha
@@ -2096,18 +2097,22 @@ def draw(self, renderer=None, inframe=False):
                 self.patch.get_transform()))
 
             renderer.draw_image(gc, round(l), round(b), im)
+            im.dirty = False
             gc.restore()
 
         if dsu_rasterized:
             for zorder, a in dsu_rasterized:
                 a.draw(renderer)
+                a.dirty = False
             renderer.stop_rasterizing()
 
         for zorder, a in dsu:
             a.draw(renderer)
+            a.dirty = False
 
         renderer.close_group('axes')
         self._cachedRenderer = renderer
+        self.dirty = False
 
     def draw_artist(self, a):
         """
@@ -2120,6 +2125,7 @@ def draw_artist(self, a):
                    ' caches the render')
             raise AttributeError(msg)
         a.draw(self._cachedRenderer)
+        a.dirty = False
 
     def redraw_in_frame(self):
         """
diff --git a/lib/matplotlib/figure.py b/lib/matplotlib/figure.py
@@ -1029,6 +1029,7 @@ def draw(self, renderer):
         Render the figure using :class:`matplotlib.backend_bases.RendererBase`
         instance *renderer*.
         """
+
         # draw the figure bounding box, perhaps none for white figure
         if not self.get_visible():
             return
@@ -1105,11 +1106,12 @@ def draw_composite():
         dsu.sort(key=itemgetter(0))
         for zorder, a, func, args in dsu:
             func(*args)
+            a.dirty = False
 
         renderer.close_group('figure')
 
         self._cachedRenderer = renderer
-
+        self.dirty = False
         self.canvas.draw_event(renderer)
 
     def draw_artist(self, a):
