Python matplotlib.animation.writers() Examples

The following are code examples for showing how to use matplotlib.animation.writers(). They are extracted from open source Python projects. You can vote up the examples you like or vote down the ones you don't like. You can also save this page to your account.

Example 1
Project: IDNNs   Author: ravidziv   File: plot_figures.py    (license) View Source Project 6 votes vote down vote up
def plot_hist(str_name, save_name='dist'):
    data_array = utils.get_data(str_name)
    params = np.squeeze(np.array(data_array['information']))
    ind_array = data_array['params']['epochsInds']
    DKL_YgX_YgT = utils.extract_array(params, 'DKL_YgX_YgT')
    p_ts = utils.extract_array(params, 'pts')
    H_Xgt = utils.extract_array(params, 'H_Xgt')

    f, (axes) = plt.subplots(3, 1)
    #axes = [axes]
    f.subplots_adjust(left=0.14, bottom=0.1, right=.928, top=0.94, wspace=0.13, hspace=0.55)
    colors = LAYERS_COLORS
    line_ani = animation.FuncAnimation(f, update_bars_num_of_ts, len(p_ts), repeat=False,
                                       interval=1, blit=False, fargs=[p_ts,H_Xgt,DKL_YgX_YgT, axes,ind_array])
    Writer = animation.writers['ffmpeg']
    writer = Writer(fps=50)
    #Save the movie
    line_ani.save(save_name+'_movie.mp4',writer=writer,dpi=250)
    plt.show() 
Example 2
Project: visual-interaction-networks_tensorflow   Author: jaesik817   File: physics_engine.py    (license) View Source Project 6 votes vote down vote up
def make_video(xy,filename):
  FFMpegWriter = manimation.writers['ffmpeg']
  metadata = dict(title='Movie Test', artist='Matplotlib',
                  comment='Movie support!')
  writer = FFMpegWriter(fps=15, metadata=metadata)
  mydpi=100;
  #fig = plt.figure(figsize=(128/mydpi,128/mydpi))
  fig = plt.figure(figsize=(32/mydpi,32/mydpi))
  plt.xlim(-200, 200)
  plt.ylim(-200, 200)
  fig_num=len(xy);
  #color=['ro','bo','go','ko','yo','mo','co'];
  color=['r','b','g','k','y','m','c'];
  with writer.saving(fig, filename, len(xy)):
    for i in range(len(xy)):
      for j in range(len(xy[0])):
        #plt.plot(xy[i,j,1],xy[i,j,0],color[j%len(color)]);
        plt.scatter(xy[i,j,1],xy[i,j,0],c=color[j%len(color)],s=0.5);
      writer.grab_frame(); 
Example 3
Project: CElegansBehaviour   Author: ChristophKirst   File: test_worm_model.py    (license) View Source Project 6 votes vote down vote up
def ani_frame():
    dpi = 600  
    fig = plt.figure()
    ax = fig.add_subplot(111)
    ax.set_aspect('equal')
    plt.xlim(0,151);
    plt.ylim(0,151);

    ws2 = copy.deepcopy(ws);
    fig.set_size_inches([5,5])


    plt.tight_layout()
    ws2.plot(ax = ax);

    shifts = np.linspace(-1,1,100);

    def update_fig(n):
      ax.cla();
      ws2 = copy.deepcopy(ws);
      ws2.bend(shifts[n], head = True, exponent = 2);
      ws2.plot(ax = ax);
      ax.set_xlim(0,151);
      ax.set_ylim(0,151);
      return ax

    #legend(loc=0)
    ani = animation.FuncAnimation(fig,update_fig,100,interval=30)
    writer = animation.writers['ffmpeg'](fps=30)

    ani.save('bend.mp4',writer=writer,dpi=dpi)
    return ani 
Example 4
Project: Interaction-networks_tensorflow   Author: jaesik817   File: physics_engine.py    (license) View Source Project 6 votes vote down vote up
def make_video(xy,filename):
  os.system("rm -rf pics/*");
  FFMpegWriter = manimation.writers['ffmpeg']
  metadata = dict(title='Movie Test', artist='Matplotlib',
                  comment='Movie support!')
  writer = FFMpegWriter(fps=15, metadata=metadata)
  fig = plt.figure()
  plt.xlim(-200, 200)
  plt.ylim(-200, 200)
  fig_num=len(xy);
  color=['ro','bo','go','ko','yo','mo','co'];
  with writer.saving(fig, filename, len(xy)):
    for i in range(len(xy)):
      for j in range(len(xy[0])):
        plt.plot(xy[i,j,1],xy[i,j,0],color[j%len(color)]);
      writer.grab_frame(); 
Example 5
Project: kvae   Author: simonkamronn   File: movie.py    (license) View Source Project 6 votes vote down vote up
def save_frames(images, filename):
    num_sequences, n_steps, w, h = images.shape

    fig = plt.figure()
    im = plt.imshow(combine_multiple_img(images[:, 0]), cmap=plt.cm.get_cmap('Greys'), interpolation='none')
    plt.axis('image')

    def updatefig(*args):
        im.set_array(combine_multiple_img(images[:, args[0]]))
        return im,

    ani = animation.FuncAnimation(fig, updatefig, interval=500, frames=n_steps)

    # Either avconv or ffmpeg need to be installed in the system to produce the videos!
    try:
        writer = animation.writers['avconv']
    except KeyError:
        writer = animation.writers['ffmpeg']
    writer = writer(fps=3)
    ani.save(filename, writer=writer)
    plt.close(fig) 
Example 6
Project: githubgraph   Author: 0x0FFF   File: visualize.py    (license) View Source Project 6 votes vote down vote up
def writevideo(self):
        #print animation.writers.list()
        #matplotlib.rcParams['animation.ffmpeg_args'] = ['-report', '/tmp/ffmpeg.log']
        #FFMpegWriter = animation.writers['ffmpeg']
        metadata = dict(title='Github Data Projects', artist='0x0FFF',
                        comment='Evolution of open source data projects')
        writer = FFMpegWriter(fps=30,
                              bitrate=8000,
                              metadata=metadata
                             )
        i = 0
        #self.iters = 200
        with writer.saving(self.fig, "/projects/personal/writer_test.mp4", 120):
            while i < self.iters:
                self.update_animation(i)
                writer.grab_frame()
                i += 1
        return 
Example 7
Project: IDNNs   Author: ravidziv   File: plot_figures.py    (license) View Source Project 5 votes vote down vote up
def plot_animation(name_s, save_name):
    """Plot the movie for all the networks in the information plane"""
    # If we want to print the loss function also
    print_loss  = False
    #The bins that we extened the x axis of the accuracy each time
    epochs_bins = [0, 500, 1500, 3000, 6000, 10000, 20000]

    data_array = utils.get_data(name_s[0][0])
    data = data_array['infomration']
    epochsInds = data_array['epochsInds']
    loss_train_data = data_array['loss_train']
    loss_test_data = data_array['loss_test_data']
    f, (axes) = plt.subplots(2, 1)
    f.subplots_adjust(left=0.14, bottom=0.1, right=.928, top=0.94, wspace=0.13, hspace=0.55)
    colors = LAYERS_COLORS
    #new/old version
    if False:
        Ix = np.squeeze(data[0,:,-1,-1, :, :])
        Iy = np.squeeze(data[1,:,-1,-1, :, :])
    else:
        Ix = np.squeeze(data[0, :, -1, -1, :, :])[np.newaxis,:,:]
        Iy = np.squeeze(data[1, :, -1, -1, :, :])[np.newaxis,:,:]
    #Interploation of the samplings (because we don't cauclaute the infomration in each epoch)
    interp_data_x = interp1d(epochsInds,  Ix, axis=1)
    interp_data_y = interp1d(epochsInds,  Iy, axis=1)
    new_x = np.arange(0,epochsInds[-1])
    new_data  = np.array([interp_data_x(new_x), interp_data_y(new_x)])
    """"
    train_data = interp1d(epochsInds,  np.squeeze(train_data), axis=1)(new_x)
    test_data = interp1d(epochsInds,  np.squeeze(test_data), axis=1)(new_x)
    """
    if print_loss:
        loss_train_data =  interp1d(epochsInds,  np.squeeze(loss_train_data), axis=1)(new_x)
        loss_test_data=interp1d(epochsInds,  np.squeeze(loss_test_data), axis=1)(new_x)
    line_ani = animation.FuncAnimation(f, update_line, len(new_x), repeat=False,
                                       interval=1, blit=False, fargs=(print_loss, new_data, axes,new_x,train_data,test_data,epochs_bins, loss_train_data,loss_test_data, colors))
    Writer = animation.writers['ffmpeg']
    writer = Writer(fps=100)
    #Save the movie
    line_ani.save(save_name+'_movie2.mp4',writer=writer,dpi=250)
    plt.show() 
Example 8
Project: IDNNs   Author: ravidziv   File: plot_figures.py    (license) View Source Project 5 votes vote down vote up
def plot_animation_each_neuron(name_s, save_name, print_loss=False):
    """Plot the movie for all the networks in the information plane"""
    # If we want to print the loss function also
    #The bins that we extened the x axis of the accuracy each time
    epochs_bins = [0, 500, 1500, 3000, 6000, 10000, 20000]
    data_array = utils.get_data(name_s[0][0])
    data = np.squeeze(data_array['information'])

    f, (axes) = plt.subplots(1, 1)
    axes = [axes]
    f.subplots_adjust(left=0.14, bottom=0.1, right=.928, top=0.94, wspace=0.13, hspace=0.55)
    colors = LAYERS_COLORS
    #new/old version
    Ix = np.squeeze(data[0,:, :, :])
    Iy = np.squeeze(data[1,:, :, :])
    #Interploation of the samplings (because we don't cauclaute the infomration in each epoch)
    #interp_data_x = interp1d(epochsInds,  Ix, axis=1)
    #interp_data_y = interp1d(epochsInds,  Iy, axis=1)
    #new_x = np.arange(0,epochsInds[-1])
    #new_data  = np.array([interp_data_x(new_x), interp_data_y(new_x)])
    """"
    train_data = interp1d(epochsInds,  np.squeeze(train_data), axis=1)(new_x)
    test_data = interp1d(epochsInds,  np.squeeze(test_data), axis=1)(new_x)

    if print_loss:
        loss_train_data =  interp1d(epochsInds,  np.squeeze(loss_train_data), axis=1)(new_x)
        loss_test_data=interp1d(epochsInds,  np.squeeze(loss_test_data), axis=1)(new_x)
    """
    line_ani = animation.FuncAnimation(f, update_line_each_neuron, Ix.shape[1], repeat=False,
                                       interval=1, blit=False, fargs=(print_loss, Ix, axes,Iy,train_data,test_data,epochs_bins, loss_train_data,loss_test_data, colors,epochsInds))
    Writer = animation.writers['ffmpeg']
    writer = Writer(fps=100)
    #Save the movie
    line_ani.save(save_name+'_movie.mp4',writer=writer,dpi=250)
    plt.show() 
Example 9
Project: CElegansBehaviour   Author: ChristophKirst   File: test_worm_model.py    (license) View Source Project 5 votes vote down vote up
def ani_frame():
    dpi = 600  
    fig = plt.figure()
    ax = fig.add_subplot(111)
    ax.set_aspect('equal')
    plt.xlim(0,151);
    plt.ylim(0,151);

    ws2 = copy.deepcopy(ws);
    fig.set_size_inches([5,5])


    plt.tight_layout()
    ws2.plot(ax = ax);

    shifts = np.linspace(0,50,100);

    def update_fig(n):
      ax.cla();
      ws2 = copy.deepcopy(ws);
      ws2.move_forward(shifts[n]);
      ws2.plot(ax = ax);
      ax.set_xlim(0,151);
      ax.set_ylim(0,151);
      return ax

    #legend(loc=0)
    ani = animation.FuncAnimation(fig,update_fig,100,interval=30)
    writer = animation.writers['ffmpeg'](fps=30)

    ani.save('forward.mp4',writer=writer,dpi=dpi)
    return ani 
Example 10
Project: CElegansBehaviour   Author: ChristophKirst   File: test_active_worm.py    (license) View Source Project 5 votes vote down vote up
def ani_frame():
    dpi = 600  
    fig = plt.figure()
    ax = fig.add_subplot(111)
    ax.set_aspect('equal')
    plt.xlim(0,151);
    plt.ylim(0,151);

    ws2 = copy.deepcopy(ws);
    fig.set_size_inches([5,5])


    plt.tight_layout()
    ws2.plot(ax = ax);

    shifts = np.linspace(0,50,100);

    def update_fig(n):
      ax.cla();
      ws2 = copy.deepcopy(ws);
      ws2.move_forward(shifts[n]);
      ws2.plot(ax = ax);
      ax.set_xlim(0,151);
      ax.set_ylim(0,151);
      return ax

    #legend(loc=0)
    ani = animation.FuncAnimation(fig,update_fig,100,interval=30)
    writer = animation.writers['ffmpeg'](fps=30)

    ani.save('forward.mp4',writer=writer,dpi=dpi)
    return ani 
Example 11
Project: CElegansBehaviour   Author: ChristophKirst   File: test_active_worm.py    (license) View Source Project 5 votes vote down vote up
def ani_frame():
    dpi = 600  
    fig = plt.figure()
    ax = fig.add_subplot(111)
    ax.set_aspect('equal')
    plt.xlim(0,151);
    plt.ylim(0,151);

    ws2 = copy.deepcopy(ws);
    fig.set_size_inches([5,5])


    plt.tight_layout()
    ws2.plot(ax = ax);

    shifts = np.linspace(-1,1,100);

    def update_fig(n):
      ax.cla();
      ws2 = copy.deepcopy(ws);
      ws2.bend(shifts[n], head = True, exponent = 2);
      ws2.plot(ax = ax);
      ax.set_xlim(0,151);
      ax.set_ylim(0,151);
      return ax

    #legend(loc=0)
    ani = animation.FuncAnimation(fig,update_fig,100,interval=30)
    writer = animation.writers['ffmpeg'](fps=30)

    ani.save('bend.mp4',writer=writer,dpi=dpi)
    return ani 
Example 12
Project: CElegansBehaviour   Author: ChristophKirst   File: video.py    (license) View Source Project 5 votes vote down vote up
def __init__(self, plots, times,
                     time_stamp = True, 
                     time_stamp_text = time_stamp_text, time_stamp_font_size = 1, time_stamp_color = 'k', time_stamp_position = None,
                     figure = None, 
                     save = None, dpi = 300, fps = 30, 
                     pause = None, verbose = True):
    self.plots = plots;
    self.times = times;
    if figure is None:
      self.figure = plt.gcf();
    else:
      self.figure = figure;
    self.pause = pause;
    
    # time stamp text  
    if time_stamp:
      self.time_stamp_text = time_stamp_text;
      tt = time_stamp_text(0,0);
      if time_stamp_position is None:
        self.time_stamp = figure.suptitle(tt, fontsize = time_stamp_font_size, color = time_stamp_color);
      else:
        self.time_stamp = plt.annotate(tt, time_stamp_position, xycoords = 'figure fraction',
                                       verticalalignment = 'center', horizontalalignment = 'left',
                                       fontsize = time_stamp_font_size, color = time_stamp_color);
    else:
      self.time_stamp = None;      
    
    # movie saver
    if save is not None:
      FFMpegWriter = manimation.writers['ffmpeg']
      #FFMpegWriter = manimation.writers['mencoder']
      metadata = dict(title='Strain %s Worm %d', artist='Chirstoph Kirst',
                      comment='C Elegans Dataset, Bargmann Lab')
      self.writer = FFMpegWriter(fps=fps, metadata=metadata);
      self.writer.setup(self.figure, save, dpi = dpi);
    else:
      self.writer = None;
      
    self.time_id = np.argmax(times[:,-1]); 
Example 13
Project: mimicry.ai   Author: fizerkhan   File: utils.py    (license) View Source Project 5 votes vote down vote up
def anim_to_mp4(anim, audio_file, filename, save_dir):
    writer = animation.writers['ffmpeg']
    writer = writer(fps=REFRESH_RATE, bitrate=SAMPLING_RATE)

    filename = os.path.join(save_dir, filename)

    if not hasattr(anim, '_encoded_video'):
        anim.save(filename + '_temp.mp4', writer=writer)
        call(['rm', filename + '.mp4'])
        call([
            'ffmpeg', '-i', filename + '_temp.mp4', '-i',
            os.path.join(save_dir, audio_file), filename + '.mp4'])
        call(['rm', filename + '_temp.mp4']) 
Example 14
Project: kuramoto_vicsek   Author: lisamnash   File: visualizations.py    (license) View Source Project 5 votes vote down vote up
def initialize_movie_writer(**kwargs):
    ''' Initializes movie writer for simulation animation.
        Parameters
        ----------
        There are only optional keyword inputs here.
        'metadata': metadata for movie.  'title', 'artist', 'comment' are metadata inputs.
        'qm' : sets frame rate.  Framerate is 40/qm.

        Returns
        ---------
        FFMpegWriter : manimation object
            writer for animation'''
    FFMpegWriter = manimation.writers['ffmpeg']

    if 'metadata' in kwargs:
        metadata = kwargs['metadata']
    else:
        metadata = dict(title='Movie Test', artist='Matplotlib',
                        comment='Movie support!')
    if 'qm' in kwargs:
        qm = kwargs['qm']
        if 1 <= qm <= 4:
            qm = qm
        else:
            qm = 1
    else:
        qm = 1

    return FFMpegWriter(fps=int(40. / qm), bitrate=3000, metadata=metadata) 
Example 15
Project: alphabetic   Author: hitokun-s   File: util.py    (license) View Source Project 5 votes vote down vote up
def animate(image_arrays, title="demo", size_inch=3, format="mp4"):
    print "Let's create awesome animation!"
    dpi = 100
    fig = plt.figure()
    ax = fig.add_subplot(111)
    ax.set_aspect('equal')
    ax.get_xaxis().set_visible(False)
    ax.get_yaxis().set_visible(False)

    height, width = image_arrays[0].shape
    image_count = len(image_arrays)

    im = ax.imshow(rand(width, height), cmap='gray', interpolation='nearest')
    im.set_clim([0, 1])
    fig.set_size_inches([size_inch, size_inch]) # size of created video
    tight_layout()

    def update_img(n):
        im.set_data(image_arrays[n])
        return im

    # legend(loc=0)
    ani = animation.FuncAnimation(fig, update_img, frames=image_count, interval=30)
    filename = ""
    if format == "mp4":
        writer = animation.writers['ffmpeg'](fps=30)
        filename = '%s.mp4' % title
        ani.save(filename, writer=writer, dpi=dpi)
    elif format == "gif":
        filename = '%s.gif' % title
        ani.save(filename, writer='imagemagick')
    else:
        print "unsupported format type!:%s" % format
        return

    print "%s is created!" % filename
    return ani

# test to creating animation 
Example 16
Project: RNNVis   Author: myaooo   File: plotter.py    (license) View Source Project 5 votes vote down vote up
def save(self, filename, fps=15, bitrate=1800):
        from matplotlib import animation
        _writer = animation.writers['ffmpeg']
        writer = _writer(fps=fps, metadata=dict(artist='Ming'), bitrate=bitrate)
        self.ani.save(filename, writer) 
Example 17
Project: derplearning   Author: John-Ellis   File: v_test.py    (license) View Source Project 5 votes vote down vote up
def ani_frame():
    fig = plt.figure()
    ax = fig.add_subplot(111)
    ax.set_aspect('equal')
    ax.get_xaxis().set_visible(False)
    ax.get_yaxis().set_visible(False)

    im = ax.imshow(rand(300,300),cmap='gray',interpolation='nearest')
    im.set_clim([0,1])
    fig.set_size_inches([5,5])


    tight_layout()


    def update_img(n):
        tmp = rand(300,300)
        im.set_data(tmp)
        return im

    #legend(loc=0)
    ani = animation.FuncAnimation(fig,update_img,300,interval=30)
    writer = animation.writers['ffmpeg'](fps=30)

    ani.save('demo.mp4',writer=writer,dpi=dpi)
    return ani 
Example 18
Project: kvae   Author: simonkamronn   File: movie.py    (license) View Source Project 5 votes vote down vote up
def save_true_generated_frames(true, generated, filename):
    num_sequences, n_steps, w, h = true.shape

    # Background is 0, foreground as 1
    true = np.copy(true[:16])
    true[true > 0.1] = 1

    # Set foreground be near 0.5
    generated = generated * .5

    # Background is 1, foreground is near 0.5
    generated = 1 - generated[:16, :n_steps]

    # Subtract true from generated so background is 1, true foreground is 0,
    # and generated foreground is around 0.5
    images = generated - true
    # images[images > 0.5] = 1.

    fig = plt.figure()
    im = plt.imshow(combine_multiple_img(images[:, 0]), cmap=plt.cm.get_cmap('gist_heat'),
                    interpolation='none', vmin=0, vmax=1)
    plt.axis('image')

    def updatefig(*args):
        im.set_array(combine_multiple_img(images[:, args[0]]))
        return im,

    ani = animation.FuncAnimation(fig, updatefig, interval=500, frames=n_steps)

    try:
        writer = animation.writers['avconv']
    except KeyError:
        writer = animation.writers['ffmpeg']
    writer = writer(fps=3)
    ani.save(filename, writer=writer)
    plt.close(fig) 
Example 19
Project: openanalysis   Author: OpenWeavers   File: matrix_animator.py    (license) View Source Project 4 votes vote down vote up
def animate(self, save=False):
        """
        Animates the Given algorithm with given Graph

        :param save: Boolean indicating weather output has to be written into output/
        """
        result = self.fn(self.graph)
        for matrix, active in result:
            self.frames.append(matrix)
            self.active.append(active)
        # Draw the original matrix
        if self.pos is None:
            self.pos = nx.nx_pydot.graphviz_layout(self.graph)
        nx.draw_networkx_nodes(self.graph, self.pos, ax=self.ax1, node_color='g', alpha=0.8,
                               node_size=self.node_size).set_edgecolor('k')
        nx.draw_networkx_edges(self.graph, self.pos, ax=self.ax1, alpha=0.6)
        if self.weights:
            nx.draw_networkx_edge_labels(self.graph, self.pos, ax=self.ax1,
                                         edge_labels=nx.get_edge_attributes(self.graph, 'weight'))
        if self.lables:
            nx.draw_networkx_labels(self.graph, self.pos, ax=self.ax1)
        # Draw its adjacancy matrix
        vmin = 0
        vmax = np.max(np.ma.array(self.frames[-1], mask=np.isinf(self.frames[-1])))
        cmap = plt.get_cmap('jet')
        cmap.set_bad('white', 1.)
        masked_array = np.ma.array(self.frames[0], mask=np.isinf(self.frames[0]))
        self.ax2.imshow(masked_array, interpolation='nearest', vmin=vmin, vmax=vmax, alpha=0.7)
        if self.matrix_labels:
            self.__plot_matrix_labels(self.frames[0], self.ax2)
        # Now start the animation
        x = animation.FuncAnimation(self.fig, self.__update, interval=1000, blit=False,
                                    repeat=False, init_func=self.__init_animation, frames=len(self.frames))
        if save:
            import errno
            import os
            path = "output"
            try:
                os.makedirs(path)
            except OSError as exc:
                if exc.errno == errno.EEXIST and os.path.isdir(path):
                    pass
                else:
                    raise
            Writer = animation.writers['ffmpeg']
            writer = Writer(fps=1, metadata=dict(artist='V'), bitrate=1800)
            from multiprocessing import Process
            import os
            path = os.path.join('output', '%s.mp4' % self.fn.__name__)
            Process(target=x.save, args=(path,), kwargs={'writer': writer}).start()
        plt.show() 
Example 20
Project: visual_mpc   Author: febert   File: animate.py    (license) View Source Project 4 votes vote down vote up
def build_figure(self):

        # plot each markevery case for linear x and y scales
        figsize = (10, 8)
        fig = plt.figure(num=1, figsize=figsize)
        axes_list = []

        num_rows = len(self.row_list)
        outer_grid = gridspec.GridSpec(num_rows, 1)
        for row in range(num_rows):
            # outer_ax = fig.add_subplot(outer_grid[row])
            # if self.row_list[row][1] != '':
            #     outer_ax.set_title(self.row_list[1])

            inner_grid = gridspec.GridSpecFromSubplotSpec(1, self.num_ex,
                              subplot_spec=outer_grid[row], wspace=0.0, hspace=0.0)

            image_row = self.row_list[row][0]

            for col in range(self.num_ex):
                ax = plt.Subplot(fig, inner_grid[col])
                ax.set_xticks([])
                ax.set_yticks([])
                axes_list.append(fig.add_subplot(ax))
                if row==0:
                    axes_list[-1].set_title('ex{}'.format(col))
                axes_list[-1].imshow(image_row[0][col], interpolation='none')

        plt.axis('off')
        fig.tight_layout()
        plt.show()

        # initialization function: plot the background of each frame

        # Set up formatting for the movie files
        Writer = animation.writers['imagemagick_file']
        writer = Writer(fps=15, metadata=dict(artist='Me'), bitrate=1800)

        # call the animator.  blit=True means only re-draw the parts that have changed.
        anim = animation.FuncAnimation(fig, self.animate, init_func=self.init,
                                       frames=13, interval=50, blit=True)
        anim.save('basic_animation.gif', writer='imagemagick')
        plt.show()