Thread: SF.net SVN: matplotlib:[8658] trunk/matplotlib (Page 32)

SourceForge Headquarters 1320 Columbia Street Suite 310 San Diego, CA 92101 +1 (858) 422-6466

Revision: 8658
          http://matplotlib.svn.sourceforge.net/matplotlib/?rev=8658&view=rev
Author:   ryanmay
Date:     2010-08-26 03:11:42 +0000 (Thu, 26 Aug 2010)

Log Message:
-----------
Add new animation framework.

Modified Paths:
--------------
    trunk/matplotlib/CHANGELOG

Added Paths:
-----------
    trunk/matplotlib/lib/matplotlib/animation.py

Modified: trunk/matplotlib/CHANGELOG
===================================================================

--- trunk/matplotlib/CHANGELOG	2010-08-25 22:13:56 UTC (rev 8657)
+++ trunk/matplotlib/CHANGELOG	2010-08-26 03:11:42 UTC (rev 8658)
@@ -1,3 +1,5 @@
+2010-08-25 Add new framework for doing animations with examples.- RM
+
 2010-08-21 Remove unused and inappropriate methods from Tick classes:
            set_view_interval, get_minpos, and get_data_interval are
            properly found in the Axis class and don't need to be

Added: trunk/matplotlib/lib/matplotlib/animation.py
===================================================================
--- trunk/matplotlib/lib/matplotlib/animation.py	                        (rev 0)
+++ trunk/matplotlib/lib/matplotlib/animation.py	2010-08-26 03:11:42 UTC (rev 8658)
@@ -0,0 +1,451 @@
+# TODO:
+# * Loop Delay is broken on GTKAgg. This is because source_remove() is not
+#   working as we want. PyGTK bug?
+# * Documentation -- this will need a new section of the User's Guide.
+#      Both for Animations and just timers.
+#   - Also need to update http://www.scipy.org/Cookbook/Matplotlib/Animations
+# * Blit
+#   * Currently broken with Qt4 for widgets that don't start on screen
+#   * Still a few edge cases that aren't working correctly
+#   * Can this integrate better with existing matplotlib animation artist flag?
+# * Example
+#   * Frameless animation - pure procedural with no loop
+#   * Need example that uses something like inotify or subprocess
+#   * Complex syncing examples
+# * Movies
+#   * Library to make movies?
+#   * RC parameter for config?
+# * Need to consider event sources to allow clicking through multiple figures
+from datetime import datetime
+
+def traceme(func):
+    def wrapper(*args):
+        print '%s -- Calling: %s %s' % (datetime.now(), func.__name__, str(args))
+        ret = func(*args)
+        print 'Returned: %s' % func.__name__
+        return ret
+    return wrapper
+
+from matplotlib.cbook import iterable
+
+class Animation(object):
+    '''
+    This class wraps the creation of an animation using matplotlib. It is
+    only a base class which should be subclassed to provide needed behavior.
+
+    *fig* is the figure object that is used to get draw, resize, and any
+    other needed events.
+
+    *event_source* is a class that can run a callback when desired events
+    are generated, as well as be stopped and started. Examples include timers
+    (see :class:`TimedAnimation`) and file system notifications.
+
+    *blit* is a boolean that controls whether blitting is used to optimize
+    drawing.
+    '''
+    def __init__(self, fig, event_source=None, blit=False):
+        self._fig = fig
+        self._blit = blit
+
+        # These are the basics of the animation.  The frame sequence represents
+        # information for each frame of the animation and depends on how the
+        # drawing is handled by the subclasses. The event source fires events
+        # that cause the frame sequence to be iterated.
+        self.frame_seq = self.new_frame_seq()
+        self.event_source = event_source
+
+        # Clear the initial frame
+        self._init_draw()
+
+        # Instead of starting the event source now, we connect to the figure's
+        # draw_event, so that we only start once the figure has been drawn.
+        self._first_draw_id = fig.canvas.mpl_connect('draw_event', self._start)
+
+        # Connect to the figure's close_event so that we don't continue to
+        # fire events and try to draw to a deleted figure.
+        self._close_id = self._fig.canvas.mpl_connect('close_event', self._stop)
+        if blit:
+            self._setup_blit()
+
+    def _start(self, *args):
+        '''
+        Starts interactive animation. Adds the draw frame command to the GUI
+        handler, calls show to start the event loop.
+        '''
+        # On start, we add our callback for stepping the animation and
+        # actually start the event_source. We also disconnect _start
+        # from the draw_events
+        self.event_source.add_callback(self._step)
+        self.event_source.start()
+        self._fig.canvas.mpl_disconnect(self._first_draw_id)
+
+    def _stop(self, *args):
+        # On stop we disconnect all of our events.
+        if self._blit:
+            self._fig.canvas.mpl_disconnect(self._resize_id)
+        self._fig.canvas.mpl_disconnect(self._close_id)
+        self.event_source.remove_callback(self._step)
+        self.event_source = None
+
+    def save(self, filename, fps=5, codec='mpeg4', clear_temp=True,
+        frame_prefix='_tmp'):
+        '''
+        Saves a movie file by drawing every frame.
+
+        *fps* is the frames per second in the movie
+
+        *codec* is the codec to be used,if it is supported by the output method.
+
+        *clear_temp* specifies whether the temporary image files should be
+        deleted.
+
+        *frame_prefix* gives the prefix that should be used for individual
+        image files.  This prefix will have a frame number (i.e. 0001) appended
+        when saving individual frames.
+        '''
+        fnames = []
+        # Create a new sequence of frames for saved data. This is different
+        # from new_frame_seq() to give the ability to save 'live' generated
+        # frame information to be saved later.
+        for idx,data in enumerate(self.new_saved_frame_seq()):
+            self._draw_next_frame(data, blit=False)
+            fname = '%s%04d.png' % (frame_prefix, idx)
+            fnames.append(fname)
+            self._fig.savefig(fname)
+
+        self._make_movie(filename, fps, codec, frame_prefix)
+
+        #Delete temporary files
+        if clear_temp:
+            import os
+            for fname in fnames:
+                os.remove(fname)
+
+    def ffmpeg_cmd(self, fname, fps, codec, frame_prefix):
+        # Returns the command line parameters for subprocess to use
+        # ffmpeg to create a movie
+        return ['ffmpeg', '-y', '-r', str(fps), '-b', '1800k', '-i',
+            '%s%%04d.png' % frame_prefix, fname]
+
+    def mencoder_cmd(self, fname, fps, codec, frame_prefix):
+        # Returns the command line parameters for subprocess to use
+        # mencoder to create a movie
+        return ['mencoder', 'mf://%s*.png' % frame_prefix, '-mf',
+            'type=png:fps=%d' % fps, '-ovc', 'lavc', '-lavcopts',
+            'vcodec=%s' % codec, '-oac', 'copy', '-o', fname]
+
+    def _make_movie(self, fname, fps, codec, frame_prefix, cmd_gen=None):
+        # Uses subprocess to call the program for assembling frames into a
+        # movie file.  *cmd_gen* is a callable that generates the sequence
+        # of command line arguments from a few configuration options.
+        from subprocess import Popen, PIPE
+        if cmd_gen is None:
+            cmd_gen = self.ffmpeg_cmd
+        proc = Popen(cmd_gen(fname, fps, codec, frame_prefix), shell=False,
+            stdout=PIPE, stderr=PIPE)
+        proc.wait()
+
+    def _step(self, *args):
+        '''
+        Handler for getting events. By default, gets the next frame in the
+        sequence and hands the data off to be drawn.
+        '''
+        # Returns True to indicate that the event source should continue to
+        # call _step, until the frame sequence reaches the end of iteration,
+        # at which point False will be returned.
+        try:
+            framedata = self.frame_seq.next()
+            self._draw_next_frame(framedata, self._blit)
+            return True
+        except StopIteration:
+            return False
+
+    def new_frame_seq(self):
+        'Creates a new sequence of frame information.'
+        # Default implementation is just an iterator over self._framedata
+        return iter(self._framedata)
+
+    def new_saved_frame_seq(self):
+        'Creates a new sequence of saved/cached frame information.'
+        # Default is the same as the regular frame sequence
+        return self.new_frame_seq()
+
+    def _draw_next_frame(self, framedata, blit):
+        # Breaks down the drawing of the next frame into steps of pre- and
+        # post- draw, as well as the drawing of the frame itself.
+        self._pre_draw(framedata, blit)
+        self._draw_frame(framedata)
+        self._post_draw(framedata, blit)
+
+    def _init_draw(self):
+        # Initial draw to clear the frame. Also used by the blitting code
+        # when a clean base is required.
+        pass
+
+    def _pre_draw(self, framedata, blit):
+        # Perform any cleaning or whatnot before the drawing of the frame.
+        # This default implementation allows blit to clear the frame.
+        if blit:
+            self._blit_clear(self._drawn_artists, self._blit_cache)
+
+    def _draw_frame(self, framedata):
+        # Performs actual drawing of the frame.
+        raise NotImplementedError('Needs to be implemented by subclasses to'
+            ' actually make an animation.')
+
+    def _post_draw(self, framedata, blit):
+        # After the frame is rendered, this handles the actual flushing of
+        # the draw, which can be a direct draw_idle() or make use of the
+        # blitting.
+        if blit and self._drawn_artists:
+            self._blit_draw(self._drawn_artists, self._blit_cache)
+        else:
+            self._fig.canvas.draw_idle()
+
+    # The rest of the code in this class is to facilitate easy blitting
+    def _blit_draw(self, artists, bg_cache):
+        # Handles blitted drawing, which renders only the artists given instead
+        # of the entire figure.
+        updated_ax = []
+        for a in artists:
+            # If we haven't cached the background for this axes object, do
+            # so now. This might not always be reliable, but it's an attempt
+            # to automate the process.
+            if a.axes not in bg_cache:
+                bg_cache[a.axes] = a.figure.canvas.copy_from_bbox(a.axes.bbox)
+            a.axes.draw_artist(a)
+            updated_ax.append(a.axes)
+
+        # After rendering all the needed artists, blit each axes individually.
+        for ax in set(updated_ax):
+            ax.figure.canvas.blit(ax.bbox)
+
+    def _blit_clear(self, artists, bg_cache):
+        # Get a list of the axes that need clearing from the artists that
+        # have been drawn. Grab the appropriate saved background from the
+        # cache and restore.
+        axes = set(a.axes for a in artists)
+        for a in axes:
+            a.figure.canvas.restore_region(bg_cache[a])
+
+    def _setup_blit(self):
+        # Setting up the blit requires: a cache of the background for the
+        # axes
+        self._blit_cache = dict()
+        self._drawn_artists = []
+        self._resize_id = self._fig.canvas.mpl_connect('resize_event',
+            self._handle_resize)
+        self._post_draw(None, self._blit)
+
+    def _handle_resize(self, *args):
+        # On resize, we need to disable the resize event handling so we don't
+        # get too many events. Also stop the animation events, so that
+        # we're paused. Reset the cache and re-init. Set up an event handler
+        # to catch once the draw has actually taken place.
+        self._fig.canvas.mpl_disconnect(self._resize_id)
+        self.event_source.stop()
+        self._blit_cache.clear()
+        self._init_draw()
+        self._resize_id = self._fig.canvas.mpl_connect('draw_event', self._end_redraw)
+
+    def _end_redraw(self, evt):
+        # Now that the redraw has happened, do the post draw flushing and
+        # blit handling. Then re-enable all of the original events.
+        self._post_draw(None, self._blit)
+        self.event_source.start()
+        self._fig.canvas.mpl_disconnect(self._resize_id)
+        self._resize_id = self._fig.canvas.mpl_connect('resize_event',
+            self._handle_resize)
+
+
+class TimedAnimation(Animation):
+    '''
+    :class:`Animation` subclass that supports time-based animation, drawing
+    a new frame every *interval* milliseconds.
+
+    *repeat* controls whether the animation should repeat when the sequence
+    of frames is completed.
+
+    *repeat_delay* optionally adds a delay in milliseconds before repeating
+    the animation.
+    '''
+    def __init__(self, fig, interval=200, repeat_delay=None, repeat=True,
+            event_source=None, *args, **kwargs):
+        # Store the timing information
+        self._interval = interval
+        self._repeat_delay = repeat_delay
+        self.repeat = repeat
+
+        # If we're not given an event source, create a new timer. This permits
+        # sharing timers between animation objects for syncing animations.
+        if event_source is None:
+            event_source = fig.canvas.new_timer()
+            event_source.interval = self._interval
+
+        Animation.__init__(self, fig, event_source=event_source, *args, **kwargs)
+
+    def _step(self, *args):
+        '''
+        Handler for getting events.
+        '''
+        # Extends the _step() method for the Animation class.  If
+        # Animation._step signals that it reached the end and we want to repeat,
+        # we refresh the frame sequence and return True. If _repeat_delay is
+        # set, change the event_source's interval to our loop delay and set the
+        # callback to one which will then set the interval back.
+        still_going = Animation._step(self, *args)
+        if not still_going and self.repeat:
+            if self._repeat_delay:
+                self.event_source.remove_callback(self._step)
+                self.event_source.add_callback(self._loop_delay)
+                self.event_source.interval = self._repeat_delay
+            self.frame_seq = self.new_frame_seq()
+            return True
+        else:
+            return still_going
+
+    def _stop(self, *args):
+        # If we stop in the middle of a loop delay (which is relatively likely
+        # given the potential pause here, remove the loop_delay callback as
+        # well.
+        self.event_source.remove_callback(self._loop_delay)
+        Animation._stop(self)
+
+    def _loop_delay(self, *args):
+        # Reset the interval and change callbacks after the delay.
+        self.event_source.remove_callback(self._loop_delay)
+        self.event_source.interval = self._interval
+        self.event_source.add_callback(self._step)
+
+
+class ArtistAnimation(TimedAnimation):
+    '''
+    Before calling this function, all plotting should have taken place
+    and the relevant artists saved.
+
+    frame_info is a list, with each list entry a collection of artists that
+    represent what needs to be enabled on each frame. These will be disabled
+    for other frames.
+    '''
+    def __init__(self, fig, artists, *args, **kwargs):
+        # Internal list of artists drawn in the most recent frame.
+        self._drawn_artists = []
+
+        # Use the list of artists as the framedata, which will be iterated
+        # over by the machinery.
+        self._framedata = artists
+        TimedAnimation.__init__(self, fig, *args, **kwargs)
+
+    def _init_draw(self):
+        # Make all the artists involved in *any* frame invisible
+        axes = []
+        for f in self.new_frame_seq():
+            for artist in f:
+                artist.set_visible(False)
+                # Assemble a list of unique axes that need flushing
+                if artist.axes not in axes:
+                    axes.append(artist.axes)
+
+        # Flush the needed axes
+        for ax in axes:
+            ax.figure.canvas.draw()
+
+    def _pre_draw(self, framedata, blit):
+        '''
+        Clears artists from the last frame.
+        '''
+        if blit:
+            # Let blit handle clearing
+            self._blit_clear(self._drawn_artists, self._blit_cache)
+        else:
+            # Otherwise, make all the artists from the previous frame invisible
+            for artist in self._drawn_artists:
+                artist.set_visible(False)
+
+    def _draw_frame(self, artists):
+        # Save the artists that were passed in as framedata for the other
+        # steps (esp. blitting) to use.
+        self._drawn_artists = artists
+
+        # Make all the artists from the current frame visible
+        for artist in artists:
+            artist.set_visible(True)
+
+class FuncAnimation(TimedAnimation):
+    '''
+    Makes an animation by repeatedly calling a function *func*, passing in
+    (optional) arguments in *fargs*.
+
+    *frames* can be a generator, an iterable, or a number of frames.
+
+    *init_func* is a function used to draw a clear frame. If not given, the
+    results of drawing from the first item in the frames sequence will be
+    used.
+    '''
+    def __init__(self, fig, func, frames=None ,init_func=None, fargs=None,
+            save_count=None, **kwargs):
+        if fargs:
+            self._args = fargs
+        else:
+            self._args = ()
+        self._func = func
+
+        # Amount of framedata to keep around for saving movies. This is only
+        # used if we don't know how many frames there will be: in the case
+        # of no generator or in the case of a callable.
+        self.save_count = save_count
+
+        # Set up a function that creates a new iterable when needed. If nothing
+        # is passed in for frames, just use itertools.count, which will just
+        # keep counting from 0. A callable passed in for frames is assumed to
+        # be a generator. An iterable will be used as is, and anything else
+        # will be treated as a number of frames.
+        if frames is None:
+            import itertools
+            self._iter_gen = itertools.count
+        elif callable(frames):
+            self._iter_gen = frames
+        elif iterable(frames):
+            self._iter_gen = lambda: iter(frames)
+            self.save_count = len(frames)
+        else:
+            self._iter_gen = lambda: iter(range(frames))
+            self.save_count = frames
+
+        # If we're passed in and using the default, set it to 100.
+        if self.save_count is None:
+            self.save_count = 100
+
+        self._init_func = init_func
+        self._save_seq = []
+
+        TimedAnimation.__init__(self, fig, **kwargs)
+
+    def new_frame_seq(self):
+        # Use the generating function to generate a new frame sequence
+        return self._iter_gen()
+
+    def new_saved_frame_seq(self):
+        # Generate an iterator for the sequence of saved data.
+        return iter(self._save_seq)
+
+    def _init_draw(self):
+        # Initialize the drawing either using the given init_func or by
+        # calling the draw function with the first item of the frame sequence.
+        # For blitting, the init_func should return a sequence of modified
+        # artists.
+        if self._init_func is None:
+            self._draw_frame(self.new_frame_seq().next())
+        else:
+            self._drawn_artists = self._init_func()
+
+    def _draw_frame(self, framedata):
+        # Save the data for potential saving of movies.
+        self._save_seq.append(framedata)
+
+        # Make sure to respect save_count (keep only the last save_count around)
+        self._save_seq = self._save_seq[-self.save_count:]
+
+        # Call the func with framedata and args. If blitting is desired,
+        # func needs to return a sequence of any artists that were modified.
+        self._drawn_artists = self._func(framedata, *self._args)


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.




Thread: SF.net SVN: matplotlib:[8658] trunk/matplotlib (Page 32)

matplotlib-checkins