python类writers()的实例源码

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

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();

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();

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)

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

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

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

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

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

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

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

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]);

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'])

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)

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

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)

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

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)

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

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