def __init__(self):

self.avail = dict()

# Returns a decorator that can be used on classes to register them under

# a name. As in:

# @register('foo')

# class Foo:

# pass

def register(self, name):

def wrapper(writerClass):

if writerClass.isAvailable():

self.avail[name] = writerClass

return writerClass

return wrapper

def list(self):

''' Get a list of available MovieWriters.'''

return list(self.avail.keys())

def is_available(self, name):

return name in self.avail

def __getitem__(self, name):

if not self.avail:

raise RuntimeError("No MovieWriters available!")

'''

def __init__(self, fps=5, codec=None, bitrate=None, extra_args=None,

metadata=None):

'''

self.fps = fps

self.frame_format = 'rgba'

if codec is None:

self.codec = rcParams['animation.codec']

else:

self.codec = codec

if bitrate is None:

self.bitrate = rcParams['animation.bitrate']

else:

self.bitrate = bitrate

if extra_args is None:

self.extra_args = list(rcParams[self.args_key])

else:

self.extra_args = extra_args

if metadata is None:

self.metadata = dict()

else:

self.metadata = metadata

@property

def frame_size(self):

'A tuple (width,height) in pixels of a movie frame.'

width_inches, height_inches = self.fig.get_size_inches()

return width_inches * self.dpi, height_inches * self.dpi

def setup(self, fig, outfile, dpi, *args):

'''

self.outfile = outfile

self.fig = fig

self.dpi = dpi

# Run here so that grab_frame() can write the data to a pipe. This

# eliminates the need for temp files.

self._run()

@contextlib.contextmanager

def saving(self, *args):

'''

# This particular sequence is what contextlib.contextmanager wants

self.setup(*args)

yield

self.finish()

def _run(self):

# Uses subprocess to call the program for assembling frames into a

# movie file. *args* returns the sequence of command line arguments

# from a few configuration options.

command = self._args()

if verbose.ge('debug'):

output = sys.stdout

else:

output = subprocess.PIPE

verbose.report('MovieWriter.run: running command: %s' %

' '.join(command))

self._proc = subprocess.Popen(command, shell=False,

stdout=output, stderr=output,

stdin=subprocess.PIPE,

creationflags=subprocess_creation_flags)

def finish(self):

'Finish any processing for writing the movie.'

self.cleanup()

def grab_frame(self, **savefig_kwargs):

'''

verbose.report('MovieWriter.grab_frame: Grabbing frame.',

level='debug')

try:

# Tell the figure to save its data to the sink, using the

# frame format and dpi.

self.fig.savefig(self._frame_sink(), format=self.frame_format,

dpi=self.dpi, **savefig_kwargs)

except RuntimeError:

out, err = self._proc.communicate()

verbose.report('MovieWriter -- Error '

'running proc:\n%s\n%s' % (out,

err), level='helpful')

raise

def _frame_sink(self):

'Returns the place to which frames should be written.'

return self._proc.stdin

def _args(self):

'Assemble list of utility-specific command-line arguments.'

return NotImplementedError("args needs to be implemented by subclass.")

def cleanup(self):

'Clean-up and collect the process used to write the movie file.'

out, err = self._proc.communicate()

self._frame_sink().close()

verbose.report('MovieWriter -- '

'Command stdout:\n%s' % out, level='debug')

verbose.report('MovieWriter -- '

'Command stderr:\n%s' % err, level='debug')

@classmethod

def bin_path(cls):

'''

return rcParams[cls.exec_key]

@classmethod

def isAvailable(cls):

'''

try:

p = subprocess.Popen(cls.bin_path(),

shell=False,

stdout=subprocess.PIPE,

stderr=subprocess.PIPE,

creationflags=subprocess_creation_flags)

p.communicate()

return True

except OSError:

'`MovieWriter` subclass that handles writing to a file.'

def __init__(self, *args, **kwargs):

MovieWriter.__init__(self, *args, **kwargs)

self.frame_format = rcParams['animation.frame_format']

def setup(self, fig, outfile, dpi, frame_prefix='_tmp', clear_temp=True):

'''

self.fig = fig

self.outfile = outfile

self.dpi = dpi

self.clear_temp = clear_temp

self.temp_prefix = frame_prefix

self._frame_counter = 0 # used for generating sequential file names

self._temp_names = list()

self.fname_format_str = '%s%%07d.%s'

@property

def frame_format(self):

'''

return self._frame_format

@frame_format.setter

def frame_format(self, frame_format):

if frame_format in self.supported_formats:

self._frame_format = frame_format

else:

self._frame_format = self.supported_formats[0]

def _base_temp_name(self):

# Generates a template name (without number) given the frame format

# for extension and the prefix.

return self.fname_format_str % (self.temp_prefix, self.frame_format)

def _frame_sink(self):

# Creates a filename for saving using the basename and the current

# counter.

fname = self._base_temp_name() % self._frame_counter

# Save the filename so we can delete it later if necessary

self._temp_names.append(fname)

verbose.report(

'FileMovieWriter.frame_sink: saving frame %d to fname=%s' %

(self._frame_counter, fname),

level='debug')

self._frame_counter += 1 # Ensures each created name is 'unique'

# This file returned here will be closed once it's used by savefig()

# because it will no longer be referenced and will be gc-ed.

return open(fname, 'wb')

def grab_frame(self, **savefig_kwargs):

'''

# Overloaded to explicitly close temp file.

verbose.report('MovieWriter.grab_frame: Grabbing frame.',

level='debug')

try:

# Tell the figure to save its data to the sink, using the

# frame format and dpi.

myframesink = self._frame_sink()

self.fig.savefig(myframesink, format=self.frame_format,

dpi=self.dpi, **savefig_kwargs)

myframesink.close()

except RuntimeError:

out, err = self._proc.communicate()

verbose.report('MovieWriter -- Error '

'running proc:\n%s\n%s' % (out,

err), level='helpful')

raise

def finish(self):

# Call run here now that all frame grabbing is done. All temp files

# are available to be assembled.

self._run()

MovieWriter.finish(self) # Will call clean-up

# Check error code for creating file here, since we just run

# the process here, rather than having an open pipe.

if self._proc.returncode:

raise RuntimeError('Error creating movie, return code: '

+ str(self._proc.returncode)

+ ' Try running with --verbose-debug')

def cleanup(self):

MovieWriter.cleanup(self)

# Delete temporary files

if self.clear_temp:

verbose.report(

'MovieWriter: clearing temporary fnames=%s' %

str(self._temp_names),

level='debug')

for fname in self._temp_names:

exec_key = 'animation.ffmpeg_path'

args_key = 'animation.ffmpeg_args'

@property

def output_args(self):

# The %dk adds 'k' as a suffix so that ffmpeg treats our bitrate as in

# kbps

args = ['-vcodec', self.codec]

# For h264, the default format is yuv444p, which is not compatible

# with quicktime (and others). Specifying yuv420p fixes playback on

# iOS,as well as HTML5 video in firefox and safari (on both Win and

# OSX). Also fixes internet explorer. This is as of 2015/10/29.

if self.codec == 'h264' and '-pix_fmt' not in self.extra_args:

args.extend(['-pix_fmt', 'yuv420p'])

if self.bitrate > 0:

args.extend(['-b', '%dk' % self.bitrate])

if self.extra_args:

args.extend(self.extra_args)

for k, v in six.iteritems(self.metadata):

args.extend(['-metadata', '%s=%s' % (k, v)])

def _args(self):

# Returns the command line parameters for subprocess to use

# ffmpeg to create a movie using a pipe.

args = [self.bin_path(), '-f', 'rawvideo', '-vcodec', 'rawvideo',

'-s', '%dx%d' % self.frame_size, '-pix_fmt', self.frame_format,

'-r', str(self.fps)]

# Logging is quieted because subprocess.PIPE has limited buffer size.

if not verbose.ge('debug'):

args += ['-loglevel', 'quiet']

args += ['-i', 'pipe:'] + self.output_args

supported_formats = ['png', 'jpeg', 'ppm', 'tiff', 'sgi', 'bmp',

'pbm', 'raw', 'rgba']

def _args(self):

# Returns the command line parameters for subprocess to use

# ffmpeg to create a movie using a collection of temp images

return [self.bin_path(), '-r', str(self.fps),

'-i', self._base_temp_name(),

'-vframes', str(self._frame_counter),

exec_key = 'animation.mencoder_path'

args_key = 'animation.mencoder_args'

# Mencoder only allows certain keys, other ones cause the program

# to fail.

allowed_metadata = ['name', 'artist', 'genre', 'subject', 'copyright',

'srcform', 'comment']

# Mencoder mandates using name, but 'title' works better with ffmpeg.

# If we find it, just put it's value into name

def _remap_metadata(self):

if 'title' in self.metadata:

self.metadata['name'] = self.metadata['title']

@property

def output_args(self):

self._remap_metadata()

lavcopts = {'vcodec': self.codec}

if self.bitrate > 0:

lavcopts.update(vbitrate=self.bitrate)

args = ['-o', self.outfile, '-ovc', 'lavc', '-lavcopts',

':'.join(itertools.starmap('{0}={1}'.format,

lavcopts.items()))]

if self.extra_args:

args.extend(self.extra_args)

if self.metadata:

args.extend(['-info', ':'.join('%s=%s' % (k, v)

for k, v in six.iteritems(self.metadata)

if k in self.allowed_metadata)])

def _args(self):

# Returns the command line parameters for subprocess to use

# mencoder to create a movie

return [self.bin_path(), '-', '-demuxer', 'rawvideo', '-rawvideo',

('w=%i:h=%i:' % self.frame_size +

'fps=%i:format=%s' % (self.fps,

supported_formats = ['png', 'jpeg', 'tga', 'sgi']

def _args(self):

# Returns the command line parameters for subprocess to use

# mencoder to create a movie

return [self.bin_path(),

'mf://%s*.%s' % (self.temp_prefix, self.frame_format),

'-frames', str(self._frame_counter), '-mf',

'type=%s:fps=%d' % (self.frame_format,

exec_key = 'animation.convert_path'

args_key = 'animation.convert_args'

@property

def delay(self):

return 100. / self.fps

@property

def output_args(self):

def _args(self):

return ([self.bin_path(),

'-size', '%ix%i' % self.frame_size, '-depth', '8',

'-delay', str(self.delay), '-loop', '0',

'%s:-' % self.frame_format]

supported_formats = ['png', 'jpeg', 'ppm', 'tiff', 'sgi', 'bmp',

'pbm', 'raw', 'rgba']

def _args(self):

return ([self.bin_path(), '-delay', str(self.delay), '-loop', '0',

'%s*.%s' % (self.temp_prefix, self.frame_format)]

'''

def __init__(self, fig, event_source=None, blit=False):

self._fig = fig

# Disables blitting for backends that don't support it. This

# allows users to request it if available, but still have a

# fallback that works if it is not.

self._blit = blit and fig.canvas.supports_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

# 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 self._blit:

self._setup_blit()

def _start(self, *args):

'''

# First disconnect our draw event handler

self._fig.canvas.mpl_disconnect(self._first_draw_id)

self._first_draw_id = None # So we can check on save

# Now do any initial draw

self._init_draw()

# Add our callback for stepping the animation and

# actually start the event_source.

self.event_source.add_callback(self._step)

self.event_source.start()

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, writer=None, fps=None, dpi=None, codec=None,

bitrate=None, extra_args=None, metadata=None, extra_anim=None,

savefig_kwargs=None):

'''

if savefig_kwargs is None:

savefig_kwargs = {}

# FIXME: Using 'bbox_inches' doesn't currently work with

# writers that pipe the data to the command because this

# requires a fixed frame size (see Ryan May's reply in this

# thread: [1]). Thus we drop the 'bbox_inches' argument if it

# exists in savefig_kwargs.

#

# [1] (http://matplotlib.1069221.n5.nabble.com/

# Animation-class-let-save-accept-kwargs-which-

# are-passed-on-to-savefig-td39627.html)

#

if 'bbox_inches' in savefig_kwargs:

if not (writer in ['ffmpeg_file', 'mencoder_file'] or

isinstance(writer,

(FFMpegFileWriter, MencoderFileWriter))):

print("Warning: discarding the 'bbox_inches' argument in "

"'savefig_kwargs' as it is only currently supported "

"with the writers 'ffmpeg_file' and 'mencoder_file' "

"(writer used: "

"'{0}').".format(

writer if isinstance(writer, six.string_types)

else writer.__class__.__name__))

savefig_kwargs.pop('bbox_inches')

# Need to disconnect the first draw callback, since we'll be doing

# draws. Otherwise, we'll end up starting the animation.

if self._first_draw_id is not None:

self._fig.canvas.mpl_disconnect(self._first_draw_id)

reconnect_first_draw = True

else:

reconnect_first_draw = False

if fps is None and hasattr(self, '_interval'):

# Convert interval in ms to frames per second

fps = 1000. / self._interval

# If the writer is None, use the rc param to find the name of the one

# to use

if writer is None:

writer = rcParams['animation.writer']

# Re-use the savefig DPI for ours if none is given

if dpi is None:

dpi = rcParams['savefig.dpi']

if codec is None:

codec = rcParams['animation.codec']

if bitrate is None:

bitrate = rcParams['animation.bitrate']

all_anim = [self]

if extra_anim is not None:

all_anim.extend(anim

for anim

in extra_anim if anim._fig is self._fig)

# If we have the name of a writer, instantiate an instance of the

# registered class.

if is_string_like(writer):

if writer in writers.avail:

writer = writers[writer](fps, codec, bitrate,

extra_args=extra_args,

metadata=metadata)

else:

import warnings

warnings.warn("MovieWriter %s unavailable" % writer)

try:

writer = writers[writers.list()[0]](fps, codec, bitrate,

extra_args=extra_args,

metadata=metadata)

except IndexError:

raise ValueError("Cannot save animation: no writers are "

"available. Please install mencoder or "

"ffmpeg to save animations.")

verbose.report('Animation.save using %s' % type(writer),

level='helpful')

# 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.

# TODO: Right now, after closing the figure, saving a movie won't work

# since GUI widgets are gone. Either need to remove extra code to

# allow for this non-existant use case or find a way to make it work.

with writer.saving(self._fig, filename, dpi):

for anim in all_anim:

# Clear the initial frame

if anim._init_func:

anim._init_draw()

for data in zip(*[a.new_saved_frame_seq()

for a in all_anim]):

for anim, d in zip(all_anim, data):

# TODO: Need to see if turning off blit is really necessary

anim._draw_next_frame(d, blit=False)

writer.grab_frame(**savefig_kwargs)

# Reconnect signal for first draw if necessary

if reconnect_first_draw:

self._first_draw_id = self._fig.canvas.mpl_connect('draw_event',

self._start)

def _step(self, *args):

'''

# 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 = next(self.frame_seq)

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)

def to_html5_video(self):

r'''Returns animation as an HTML5 video tag.

VIDEO_TAG = r'''<video {size} {options}>

# Cache the the rendering of the video as HTML

if not hasattr(self, '_base64_video'):

# First write the video to a tempfile. Set delete to False

# so we can re-open to read binary data.

with tempfile.NamedTemporaryFile(suffix='.m4v',

delete=False) as f:

# We create a writer manually so that we can get the

# appropriate size for the tag

Writer = writers[rcParams['animation.writer']]

writer = Writer(codec='h264',

bitrate=rcParams['animation.bitrate'],

fps=1000. / self._interval)

self.save(f.name, writer=writer)

# Now open and base64 encode

with open(f.name, 'rb') as video:

vid64 = base64.encodebytes(video.read())

self._base64_video = vid64.decode('ascii')

self._video_size = 'width="{0}" height="{1}"'.format(

*writer.frame_size)

# Now we can remove

os.remove(f.name)

# Default HTML5 options are to autoplay and to display video controls

options = ['controls', 'autoplay']

# If we're set to repeat, make it loop

if self.repeat:

options.append('loop')

return VIDEO_TAG.format(video=self._base64_video,

size=self._video_size,

options=' '.join(options))

def _repr_html_(self):

r'IPython display hook for rendering.'

fmt = rcParams['animation.html']

if fmt == 'html5':

'''

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):

'''

# 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:

self.frame_seq = self.new_frame_seq()

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

return True