def plot(self, save=False, ani_name=None, ImageMagickLoc=None, close_after_animation=True): if self.visualize: self.get_visualize() else: update, time = self.get_draw( close_after_animation=close_after_animation, save=save) for ax in self.axes: ax.set_xlim(self.x_lim) ax.set_ylim(self.y_lim) ani = animation.FuncAnimation(self.fig, update, time, interval=1, blit=True, repeat=close_after_animation) if save is True and ImageMagickLoc is not None: plt.rcParams['animation.convert_path'] = ImageMagickLoc writer = animation.ImageMagickFileWriter(fps=100) ani.save(ani_name if ani_name else 'gif_1.gif', writer=writer) else: # TODO(Darius): Figure out a way to get Matplotlib to close the figure nicely after animation is done try: plt.show() except e as Exception: # _tkinter.TclError: invalid command name "pyimage10" pass plt.clf() plt.cla() plt.close()
def plot(self, save=False, ani_name=None, ImageMagickLoc=None, close_after_animation=True): if self.visualize: self.get_visualize() else: update, time = self.get_draw( close_after_animation=close_after_animation, save=save) for ax in self.axes: ax.set_xlim(self.x_lim) ax.set_ylim(self.y_lim) ani = animation.FuncAnimation(self.fig, update, time, interval=1, blit=True, repeat=close_after_animation) if save is True and ImageMagickLoc is not None: plt.rcParams['animation.convert_path'] = ImageMagickLoc writer = animation.ImageMagickFileWriter(fps=100) ani.save(ani_name if ani_name else 'gif_1.gif', writer=writer) else: try: plt.show() except e as Exception: pass plt.clf() plt.cla() plt.close()
def write_output_inundanimation(outputfile, skip): print("writing animated inundation file...") import matplotlib matplotlib.use('Agg') import matplotlib.animation as animation from matplotlib import pyplot as plt global glinundarr fps=5 fig, pl= plt.subplots(figsize=(5, 5)) #preparing empty frame nts=glinundarr.shape[0] temp=np.zeros_like(glinundarr[0,:,:]).astype(float) temp[:]=0 im = pl.imshow(temp, cmap=plt.cm.RdBu) dates=pd.date_range(glrecdate[0], freq="M", periods=len(glrecdate)).strftime("%b %Y") #entire period #preparing canvas pl.set_yticks([]) pl.set_xticks([]) tx=pl.text(0.7,0.9,dates[0], transform=pl.transAxes) def plotflood(ts): if ts%10==0: print ("ts="+str(ts)) tx.set_text(dates[ts]) frame=np.flipud(glinundarr[ts,:,:].astype(float)) frame[frame==0]=np.nan im.set_array(frame) return im, ani = animation.FuncAnimation(fig, plotflood, range(skip,nts)) writer = animation.ImageMagickFileWriter(fps=fps) ani.save(outputfile, writer=writer)
def gazePlotter(data, name=None, flattened=True, save=False, output_path=None, plot=True): ''' Plots and saves the gaze pattern as animation :param data: gaze data vector :param name: name of the file to be saved :param flattened: boolean to know if the data vector is flat :param save: boolean to determine save or not :param output_path: string path to the output vector :param plot: Boolean to display the plot :return: none ''' x = [] y = [] if flattened: for i in range(0, len(data) - 1, 2): x.append(data[i]) y.append(data[i + 1]) else: for point in data: x.append(point[0]) y.append(point[1]) fig = plt.figure() # plt.rcParams['animation.ffmpeg_path'] = 'C:/ffmpeg/ffmpeg.exe' plt.xlim(0, 2560) plt.ylim(1440, 0) line, = plt.plot(x, y) def animate(ii): line.set_data(x[:ii + 1], y[:ii + 1]) return line writer = animation.ImageMagickFileWriter() # for ubuntu # writers = animation.writers['ffmpeg'] # writer = writers(fps=30, metadata=dict(artist='Me'), bitrate=1800) # writer = animation.FFMpegFileWriter(fps=15, metadata=dict(artist='Me'), bitrate=1800) img = plt.imread(args.proj_dir + '/images/CXR129_IM-0189-1001.jpg') plt.imshow(img) ani = animation.FuncAnimation(fig, animate, frames=50, interval=100) if save is True: if not os.path.exists(output_path + str(name.split('/')[0])): os.makedirs(output_path + str(name.split('/')[0])) ani.save(output_path + str(name) + str() + '.mp4', writer='ffmpeg', fps=15) if plot is True: plt.show()
def animo(statelist: list, size: int, export=False): '''Visualize the matrix states contained in statelist (as lists of lists) by using matplotlib `export` argument defaults to False and decides if the animation is shown on-screen or saved as gif''' global toDisplay global im stateNum = len( statelist ) #set delay between updates of figure depending on amount of states which is relative to the size if stateNum > 400: interval = 15 elif stateNum > 200: interval = 40 elif stateNum > 100: interval = 60 else: interval = 80 fig = plt.gcf( ) #maybe this and .figure both work but now that its running i aint touching it toDisplay = statelist # make global... dumb TODO use OOP im = plt.imshow(toDisplay[0], cmap=CMAP) # set initial frame, also initialize im anim = animation.FuncAnimation(fig, funcAnim, frames=len(toDisplay), interval=interval, repeat=False, blit=True) fig.suptitle(f"L-Shape Animation {size}x{size}") if (export): if ( len(statelist) < 100 ): #change speed of gif depending on amount of states ~ size of matrix fps = 3 elif (len(statelist) < 1000): fps = 7 else: fps = 30 writer = animation.ImageMagickFileWriter( fps=fps ) #very important when using `writer='imagemagick'` shit doesn't work!!!!! anim.save('docs/img/recent.gif', writer=writer, progress_callback=printprog ) #needs to have imagemagick installed :) else: plt.show() #display matplotlib animation
def animate_plot_Func(pred_isings_all_timesteps, prey_isings_all_timesteps, settings, ax, fig, rep, t, save_folder): ''' Uses FuncAnimation - works and currently implemented''' my_path = os.path.abspath(__file__) #mpl.rcParams["savefig.directory"] = my_path + 'tmp/' if settings['server_mode']: plt.rcParams['animation.ffmpeg_path'] = '/data-uwks159/home/jprosi/ffmpeg-4.2.1-linux-64/ffmpeg' #'/usr/local/bin/ffmpeg' elif settings['laptop_mode']: plt.rcParams['animation.ffmpeg_path'] = "D:/Program Files/ffmpeg-20191217-bd83191-win64-static/bin/ffmpeg.exe" if settings['LoadIsings']: path = '/save/{}/animation_loaded_gen{}/'.format(settings['loadfile'], int(settings['iter']) + rep) # when loading file generation counting starts from 0 again, thats why we have to add the iteration that was loaded else: path = '/{}animation_gen{}/'.format(save_folder, rep) savename = 'ani-{}-{}ts-gen{}.mp4'.format(time.strftime("%Y%m%d-%H%M%S"), t, rep) savepath = savename cur_wdir = os.getcwd() path = cur_wdir.replace('\\','/') + path if not os.path.exists(path): os.makedirs(path) os.chdir(path) design_figure(settings, fig, ax) initial_plot(pred_isings_all_timesteps[0], prey_isings_all_timesteps[0], settings, ax) #plt.savefig('firstframe.png', dpi =100, bbox_inches = 'tight') if not (len(pred_isings_all_timesteps) == len(prey_isings_all_timesteps)): raise Exception('Length of "pred_isings_all_timesteps" not equal to "prey_isings_all_timesteps"') ani = animation.FuncAnimation(fig, __update_plot, fargs=[pred_isings_all_timesteps, prey_isings_all_timesteps, settings, ax, fig], interval=1, frames=len(pred_isings_all_timesteps)) if True: #ffmpeg does not work on server, therefore default writer used Writer = animation.FFMpegFileWriter writer = Writer(fps=settings['animation_fps'], metadata=dict(artist='Sina Abdollahi, Jan Prosi'), bitrate=1800) writer.frame_format = 'png' ani.save(savepath, writer=writer) elif False: #Using defaul writer instead of imagemagick ani.save(savepath, dpi=100, writer='imagemagick', fps=settings['animation_fps']) #TODO: dpi=100 writer='imagemagick', elif False: writer = animation.ImageMagickFileWriter(fps=settings['animation_fps'], metadata=dict(artist='Sina Abdollahi, Jan Prosi'), bitrate=1800) ani.save('location.gif', writer=writer, dpi = 100)# print('\nAnimation successfully saved at {}'.format(savepath)) os.chdir(cur_wdir)
def plot(self, save=False, ani_name=None, ImageMagickLoc=None, close_after_animation=True): update, time = self.get_draw( close_after_animation=close_after_animation, save=save) #for ax in self.axes: self.axes.set_xlim(self.x_lim) self.axes.set_ylim(self.y_lim) ani = animation.FuncAnimation(self.fig, update, time, interval=1, blit=True, repeat=close_after_animation, repeat_delay=3000) if save is True and ImageMagickLoc is not None: #plt.rcParams['savefig.bbox'] = "tight" #plt.rcParams['savefig.orientation'] = "landscape" #plt.rcParams['figure.autolayout'] = True plt.rcParams['animation.convert_path'] = ImageMagickLoc writer = animation.ImageMagickFileWriter(fps=30, bitrate=1800) ani.save(ani_name if ani_name else 'gif_1.gif', writer=writer, dpi=300) else: # TODO(Darius): Figure out a way to get Matplotlib to close the figure nicely after animation is done try: plt.show() except e as Exception: # _tkinter.TclError: invalid command name "pyimage10" pass plt.clf() plt.cla() plt.close()
def visualize(self, save = False, ani_name = None): fig = plt.figure(self.fig_n) self.fig_n += 1 period = self.complex_coord_1.size time = np.arange(period) circles_loc_1 = np.zeros((2*(period//2-1), period), dtype = np.complex_) circles_rad_1 = np.zeros((2*(period//2-1)), dtype = np.float_) for idx, multiple in enumerate(chain(range(-(period//2)+1, 0), range(1, period//2))): cn_1 = self.cn(time, period, multiple, self.complex_coord_1) circles_rad_1[idx] = np.absolute(cn_1) circles_loc_1[idx, :] = self.polar_locations(time, period, multiple, cn_1) circles_loc_1 = circles_loc_1[np.argsort(circles_rad_1)[::-1]] circles_loc_1 = np.add.accumulate(circles_loc_1, 0) ax = fig.add_subplot(111) draw, = ax.plot(0,0) n_text = ax.text(0.02, 0.95, 'Number of Points = 0', transform=ax.transAxes) def ani(i): draw.set_data(circles_loc_1[i, :].real, circles_loc_1[i, :].imag) n_text.set_text('Number of Fourier Terms = %d' % i) return ([]) time = np.arange(0, period//2, 8) ax.set_xlim(np.amin(circles_loc_1[-1].real), np.amax(circles_loc_1[-1].real)) ax.set_ylim(np.amax(circles_loc_1[-1].imag), np.amin(circles_loc_1[-1].imag)) ani = animation.FuncAnimation(fig, ani, time, interval=1, blit=True) if save is True: plt.rcParams['animation.convert_path'] = 'C:\Program Files\ImageMagick-7.0.8-Q16/magick.exe' writer = animation.ImageMagickFileWriter(fps = 100) ani.save(ani_name, writer=writer) else: plt.show() plt.clf() plt.cla() plt.close()
def wind_field(self, field_name, u_grid, v_grid, start, end, step=1, interval=1, dimensions=False, datapath='none'): """ Makes animation of field streamlines over a given period. param: field_name: string, model layer being animated either ocean, 250, 750. param: u_grid: u velocities from a u_grid call. Should correspond to field name. param: v_grid: v velocities from a v_grid call. Should correspond to field name. param: start: integer, start time of animation (column index of data file). param: end: integer, end time of animation (column index of data file). option: step: integer, step between index of frames. option: interval: integer, delay between animation frames in seconds. option: dimensions: boolean, whether to dimensionalise the animation. option: datapath: string, save location for video. """ # Animation settings writer = ani.ImageMagickFileWriter() # Plot details determined by field being animated if (field_name == "phi250"): title = '250 hPa Wind Field' save = '250hPa-Wind-Field' elif (field_name == "phi750"): title = '750 hPa Wind Field' save = '750hPa-Wind-Field' elif (field_name == "phiOcean"): title = 'Ocean Velocity Field' save = 'Ocean-Velocity-Field' else: print('Please provide valid field') return # Setting up first frame fig, ax = plt.subplots() [nx, ny] = u_grid.shape[1], u_grid.shape[0] if (dimensions): x_values = np.linspace( 0, (2 * np.pi) / n, nx) * L * 1.e-3 # L is dimensionalisation constant y_values = np.linspace( 0, np.pi, ny) * L * 1.e-3 #1.e-3 is m to Km conversion u_grid[:, :, :] = u_grid[:, :, :] * ( f0 * L) # f0 * L is dimensionalisation constant v_grid[:, :, :] = v_grid[:, :, :] * (f0 * L) else: x_values = np.linspace(0, (2 * np.pi) / n, nx) y_values = np.linspace(0, np.pi, ny) speed = np.sqrt(u_grid[:, :, :]**2 + v_grid[:, :, :]**2) speed = np.sqrt(u_grid[:, :, :]**2 + v_grid[:, :, :]**2) colorange = np.linspace(speed.min(), speed.max(), 30, endpoint=True) xx, yy = np.meshgrid(x_values, y_values) # Animation function def frame(t): fig.clf() # Calculating time time_model = tw * (t + 1 ) # tw is write step, t is index of data file time_seconds = time_model / f0 # time dimension given by f0 time_hours = time_seconds / 3600 time_days = floor( time_seconds / 86400 ) # Floor function is to prevent rounding up in formatting time_months = time_seconds / 2.628e6 time_years = time_days / 365 # Animating title if (dimensions): time_stamp = ', {:02.0f} (days) {:02.0f} (hours)'.format( time_days, time_hours % 24) else: time_stamp = ', {:05.0f} (step)'.format(time_model) plt.title(title + time_stamp) # Animating contour ax = plt.contourf(xx, yy, speed[:, :, t], colorange, cmap=cm.Blues) if (dimensions): cbar_unit = 'ms$^{-1}$' else: cbar_unit = '' cbar = plt.colorbar( label=cbar_unit) # assumed units, check matches param file ax = plt.quiver(xx, yy, u_grid[:, :, t], v_grid[:, :, t]) # Plot details if (dimensions): plt.xlabel('x (km)') plt.ylabel('y (km)') else: plt.xlabel("x'") plt.ylabel("y'") animation = ani.FuncAnimation(fig, frame, range(start, end, step), interval=interval * 1e+3, blit=False) animation.save(datapath + '/' + save + '.gif', writer=writer)
new_val = helper(x, movement, 1) return (new_val, y) elif direction == 2: new_val = helper(y, movement, -1) return (x, new_val) else: new_val = helper(x, movement, -1) return (new_val, y) def animate(i): global cur1, cur2, cur3 cur1 = update(cur1, 1) point1.center = cur1 cur2 = update(cur2, 2) point2.center = cur2 cur3 = update(cur3, 3) point3.center = cur3 return point1, point2, point3, anim = animation.FuncAnimation(fig, animate, init_func=init, frames=1000, interval=20, blit=True) writergif = animation.ImageMagickFileWriter() anim.save('filename.gif', writer=writergif)
def plot_disk_simulation(te, dx, dy, r, tau, d_star, plot_data, animate_plot=False, save=False): ''' This function creates a plot that shows the eclipsing system The relevant light curve, and the corresponding gradient of the light curve. Parameters ---------- te : float duration of the eclipse. dx : array_like (1-D) Array containing all the circle centres shifted by dx in the x direction. dy : array_like (1-D) Array containing all the circle centres shifted by dy in the y direction. r : array_like (1-D) array containing the radii of the rings to be simulated. these should be in increasing order and should not contain 0. tau : array_like (1-D) array containing the opacity of the rings specified above. values should be between 0 and 1 and the array should have the same length as r. d_star : float size of the star in days. plot_data : array_like (2-D) array consisting of 4 vectors. [0] = time, [1] = light curve if the star was a laser beam, [2] = the light curve with a finite sized star, [3] = the gradients measured. animate_plot : boolean determines whether or not to make an animation of the transit Returns ------- Plot or Animation Notes ----- This function only works for a single (dx, dy) point ''' # determining the angular geometry of the system a, b, t, i = find_ellipse_parameters(te, dx, dy) # creating the patch objects rings = vector_rings(r, tau, i, t, dy) # getting the limits of the data time = plot_data[0] # drawing the star path xy = (time[0], -d_star / 2.) width = time[-1] - time[0] star_path = patches.Rectangle(xy, width, d_star, color='g', alpha=0.5) ##### creating the figure ##### # title with all the information pertaining to the disk system title1 = 'Eclipse of a Circumplanetary Disk \n' title2 = 'Star - $R_{*}$ = %.2f days, b = %.2f days \n' % (d_star / 2., dy[0]) title3 = 'Disk - $i$ = %.2f$^o$, $\\phi$ = %.2f$^o$, ' % (i, t) title4 = '$R_{disk}$ = ' + str(r) + ' days, ' title5 = '$\\tau$ = ' + str(tau) title = title1 + title2 + title3 + title4 + title5 #creating the figure fig = plt.figure(figsize=(8, 10)) fig.suptitle(title) ax0 = plt.subplot2grid((4, 1), (0, 0), rowspan=2) # plot 1 - transit ax0.set_xlim(time[0], time[-1]) ax0.set_ylim(-d_star, d_star) ax0.set_aspect('equal') ax0.set_adjustable('box') ax0.set_ylabel('y [days]') ax0.axhline(y=0, color='k') for ring in rings: ax0.add_patch(ring) ax0.add_patch(star_path) # plot 2 - light curve ax1 = plt.subplot2grid((4, 1), (2, 0), sharex=ax0) ax1.set_ylim(-0.05, 1.05) ax1.set_xlim(time[0], time[-1]) ax1.set_ylabel('normalised flux') # plot 3 - gradients ax2 = plt.subplot2grid((4, 1), (3, 0), sharex=ax0) ax2.set_ylim(-0.05, 1.05) ax2.set_xlim(time[0], time[-1]) ax2.set_ylabel('gradient') ax2.set_xlabel('time [days]') def animate(i): ''' This function produces the animation for the plot ''' # clearing the first plot of lines if i == 0: for artist in ax1.lines + ax1.collections: artist.remove() for artist in ax2.lines + ax2.collections: artist.remove() # clearing the previous star try: stars[i - 1].remove() stars[i - 1].remove() except: None # moving the star star = stars[i] ax0.add_artist(star) # transmission of rings ax1.plot(data[0, :i], data[1, :i], 'r-') # light curve ax1.plot(data[0, :i], data[2, :i], 'g-') # gradient curve ax2.plot(data[0, :i], data[3, :i], 'g-') if animate_plot == True: stars = [ patches.Circle((x, 0), d_star / 2., color='g', alpha=0.7) for x in plot_data[0] ] ani = animation.FuncAnimation(fig, animate, frames=len(time), interval=50, repeat_delay=250) writer = animation.ImageMagickFileWriter(fps=20) if save == True: ani.save('eclipse.gif', writer=writer) else: fig.show() else: # add star star = patches.Circle((time[0] + d_star, 0), d_star / 2., color='g', alpha=0.7) ax0.add_patch(star) # add ring transmission ax1.plot(time, plot_data[1], 'r-o') ax1.plot(time, plot_data[2], 'g-o') # add gradient ax2.plot(time, plot_data[3], 'g-o') if save == True: fig.savefig('test.png') else: fig.show() return None
Var = transpose(walks['Variance'].value) Sk = transpose(walks['Skewness'].value) Ku = transpose(walks['Kurtosis'].value) t = transpose(walks['Time'].value) Pe = walks['Peclet'].value walks.close() ani = animate_stats(Me,Var,Sk,Ku,nby,nbz,Pe,t) if (True): print "Saving animation to disk (may take quite a while)..." # # dpi=200 gives decent quality for the filesize. Takes about 5-10 minutes to make. # assume a file input '***.h5', chop off the suffix and add the '.mp4'. fname = sys.argv[2] mywriter = anim.ImageMagickFileWriter() # mywriter = anim.FFMpegWriter() ani.save(fname,dpi=120,fps=12,writer=mywriter) else: pyplot.show(block=False) # end if print "Done."
def draw(self, n_approximations = 500, speed = 1, mode = 1, save = False , ani_name = None): fig = plt.figure(1) self.fig_n += 1 # Avoiding aliasing n_approximations = self.complex_coord_1.size//2 if n_approximations > self.complex_coord_1.size//2 else n_approximations if self.n_images == 1 and mode == 1: axes = {0: fig.add_subplot(111)} final_points, lst_circles_lst, lst_circles_loc = self.get_one_circle_one_image(axes, n_approximations) con1 = con2 = con3 = con4 = None elif self.n_images == 1 and mode == 2: axes = {i: fig.add_subplot(int(j)) for i, j in zip(range(4), ("224", "222", "221", "223"))} final_points, lst_circles_lst, lst_circles_loc = self.get_two_circles_one_image(axes, n_approximations) con1 = ConnectionPatch(xyA=(0,0), xyB=(0,0), coordsA="data", coordsB="data", axesA=axes[0], axesB=axes[3], zorder=25, fc="w", ec="darkblue", lw=2) con2 = ConnectionPatch(xyA=(0,0), xyB=(0,0), coordsA="data", coordsB="data", axesA=axes[0], axesB=axes[1], zorder=25, fc="w", ec="darkblue", lw=2) con3 = ConnectionPatch(xyA=(0,0), xyB=(0,0), coordsA="data", coordsB="data", axesA=axes[2], axesB=axes[3], zorder=25, fc="w", ec="darkblue", lw=2) con4 = ConnectionPatch(xyA=(0,0), xyB=(0,0), coordsA="data", coordsB="data", axesA=axes[2], axesB=axes[1], zorder=25, fc="w", ec="darkblue", lw=2) axes[0].add_artist(con1) axes[0].add_artist(con2) axes[2].add_artist(con3) axes[2].add_artist(con4) axes[1].set_zorder(-1) axes[3].set_zorder(-1) else: axes = {i: fig.add_subplot(int(j)) for i, j in zip(range(4), ("224", "222", "221", "223"))} final_points, lst_circles_lst, lst_circles_loc = self.get_two_circles_two_images(axes, n_approximations) con1 = ConnectionPatch(xyA=(0,0), xyB=(0,0), coordsA="data", coordsB="data", axesA=axes[0], axesB=axes[3], zorder=25, fc="w", ec="darkblue", lw=2) con2 = ConnectionPatch(xyA=(0,0), xyB=(0,0), coordsA="data", coordsB="data", axesA=axes[0], axesB=axes[1], zorder=25, fc="w", ec="darkblue", lw=2) con3 = ConnectionPatch(xyA=(0,0), xyB=(0,0), coordsA="data", coordsB="data", axesA=axes[2], axesB=axes[3], zorder=25, fc="w", ec="darkblue", lw=2) con4 = ConnectionPatch(xyA=(0,0), xyB=(0,0), coordsA="data", coordsB="data", axesA=axes[2], axesB=axes[1], zorder=25, fc="w", ec="darkblue", lw=2) axes[0].add_artist(con1) axes[0].add_artist(con2) axes[2].add_artist(con3) axes[2].add_artist(con4) axes[1].set_zorder(-1) axes[3].set_zorder(-1) def update(i): nonlocal con1, con2, con3, con4 for n, circles_lst in enumerate(lst_circles_lst): for idx, circle in enumerate(circles_lst): circle.center = (lst_circles_loc[n][idx, i].real, lst_circles_loc[n][idx, i].imag) if mode == 1 and self.n_images == 1: final_points[0].set_data(lst_circles_loc[0][-1, :i].real, lst_circles_loc[0][-1, :i].imag) elif mode == 2 and self.n_images == 1: final_points[0].set_data(lst_circles_loc[0][-1, :i].real, lst_circles_loc[1][-1, :i].imag) final_points[1].set_data(lst_circles_loc[1][-1, :i].real, lst_circles_loc[0][-1, :i].imag) con1.remove() con2.remove() con3.remove() con4.remove() con1 = ConnectionPatch(xyA=(lst_circles_loc[0][-1, i].real, lst_circles_loc[0][-1, i].imag), xyB=(lst_circles_loc[0][-1, i].real, lst_circles_loc[1][-1, i].imag), coordsA="data", coordsB="data", axesA=axes[0], axesB=axes[1], zorder=25, fc="w", ec="darkblue", lw=2) con2 = ConnectionPatch(xyA=(lst_circles_loc[0][-1, i].real, lst_circles_loc[0][-1, i].imag), xyB=(lst_circles_loc[1][-1, i].real, lst_circles_loc[0][-1, i].imag), coordsA="data", coordsB="data", axesA=axes[0], axesB=axes[3], zorder=25, fc="w", ec="darkblue", lw=2) con3 = ConnectionPatch(xyA=(lst_circles_loc[1][-1, i].real, lst_circles_loc[1][-1, i].imag), xyB=(lst_circles_loc[0][-1, i].real, lst_circles_loc[1][-1, i].imag), coordsA="data", coordsB="data", axesA=axes[2], axesB=axes[1], zorder=25, fc="w", ec="darkblue", lw=2) con4 = ConnectionPatch(xyA=(lst_circles_loc[1][-1, i].real, lst_circles_loc[1][-1, i].imag), xyB=(lst_circles_loc[1][-1, i].real, lst_circles_loc[0][-1, i].imag), coordsA="data", coordsB="data", axesA=axes[2], axesB=axes[3], zorder=25, fc="w", ec="darkblue", lw=2) axes[0].add_artist(con1) axes[0].add_artist(con2) axes[2].add_artist(con3) axes[2].add_artist(con4) else: final_points[0].set_data(lst_circles_loc[0][-1, :i].real, lst_circles_loc[1][-1, :i].imag) final_points[1].set_data(lst_circles_loc[1][-1, :i].real, lst_circles_loc[0][-1, :i].imag) con1.remove() con2.remove() con3.remove() con4.remove() con1 = ConnectionPatch(xyA=(lst_circles_loc[0][-1, i].real, lst_circles_loc[0][-1, i].imag), xyB=(lst_circles_loc[0][-1, i].real, lst_circles_loc[1][-1, i].imag), coordsA="data", coordsB="data", axesA=axes[0], axesB=axes[1], zorder=25, fc="w", ec="darkblue", lw=2) con2 = ConnectionPatch(xyA=(lst_circles_loc[0][-1, i].real, lst_circles_loc[0][-1, i].imag), xyB=(lst_circles_loc[1][-1, i].real, lst_circles_loc[0][-1, i].imag), coordsA="data", coordsB="data", axesA=axes[0], axesB=axes[3], zorder=25, fc="w", ec="darkblue", lw=2) con3 = ConnectionPatch(xyA=(lst_circles_loc[1][-1, i].real, lst_circles_loc[1][-1, i].imag), xyB=(lst_circles_loc[0][-1, i].real, lst_circles_loc[1][-1, i].imag), coordsA="data", coordsB="data", axesA=axes[2], axesB=axes[1], zorder=25, fc="w", ec="darkblue", lw=2) con4 = ConnectionPatch(xyA=(lst_circles_loc[1][-1, i].real, lst_circles_loc[1][-1, i].imag), xyB=(lst_circles_loc[1][-1, i].real, lst_circles_loc[0][-1, i].imag), coordsA="data", coordsB="data", axesA=axes[2], axesB=axes[3], zorder=25, fc="w", ec="darkblue", lw=2) axes[0].add_artist(con1) axes[0].add_artist(con2) axes[2].add_artist(con3) axes[2].add_artist(con4) return ([]) period = self.complex_coord_1.size ani = animation.FuncAnimation(fig, update, np.arange(0, period, speed), interval=1, blit=True) if self.n_images == 1 and mode == 1: lim_1 = np.amin(lst_circles_loc[0][-1].real), np.amax(lst_circles_loc[0][-1].real) lim_2 = np.amax(lst_circles_loc[0][-1].imag), np.amin(lst_circles_loc[0][-1].imag) else: lim_1 = min(np.amin(lst_circles_loc[0][-1].real), np.amin(lst_circles_loc[1][-1].real)), max(np.amax(lst_circles_loc[0][-1].real), np.amax(lst_circles_loc[1][-1].real)) lim_2 = max(np.amax(lst_circles_loc[0][-1].imag), np.amax(lst_circles_loc[1][-1].imag)), min(np.amin(lst_circles_loc[0][-1].imag), np.amin(lst_circles_loc[1][-1].imag)) for key, ax in axes.items(): ax.set_xlim(lim_1) ax.set_ylim(lim_2) if save is True: plt.rcParams['animation.convert_path'] = 'C:\Program Files\ImageMagick-7.0.8-Q16/magick.exe' writer = animation.ImageMagickFileWriter(fps = 100) ani.save(ani_name, writer=writer) else: plt.show() plt.clf() plt.cla() plt.close()
def plotflood(ts): if ts % 10 == 0: print("ts=" + str(ts)) inu = sa.iloc[ts, :] amap = np.zeros_like(mf).astype(float) amap[:] = np.nan for key in codes.keys(): area = inu[codes[key]] sel = np.where(unitsf == key)[0] for x in sel: prob = st.norm.cdf(area, mf[x], sigmaf[x]) if thresh > 0: if prob > thresh: amap[x] = 1 else: amap[x] = prob amap = np.flipud(amap.reshape(nrow, ncol)) tx.set_text(sa.index.strftime('%Y %B')[ts]) im.set_array(amap) #plt.imshow(amap) #plt.show() return im, ani = animation.FuncAnimation(fig, plotflood, range(skip, nts)) writer = animation.ImageMagickFileWriter(fps=fps) ani.save(output_file + ".gif", writer=writer)
def mk_animation(self, field_name, velocity_grid, start, end, step=1, dimensions=False, datapath='none'): """ Makes animation of field streamlines over a given period. param: field_name: string, name of field being animated. param: velocity_grid: output of u_grid or v_grid. Should correspond to field name. param: start: integer, start time of animation (column index of data file). param: end: integer, end time of animation (column index of data file). option: step: integer, step time of animation (no. of indices of data file). option: datapath: string, save location for video. """ # Animation settings interval = 2.e-2 # delay between frames in seconds writer = ani.ImageMagickFileWriter() # Setting up first frame fig, ax = plt.subplots() [nx, ny] = velocity_grid.shape[1], velocity_grid.shape[0] colorange = np.linspace(velocity_grid.min(), velocity_grid.max(), 30, endpoint=True) # Colorbar if (dimensions): colorange = colorange * (f0 * L) if (dimensions): x_values = np.linspace(0, (2 * L * np.pi) / n, nx) # length dimension given by L y_values = np.linspace(0, np.pi * L, ny) else: x_values = np.linspace(0, (2 * np.pi) / n, nx) y_values = np.linspace(0, np.pi, ny) xx, yy = np.meshgrid(x_values, y_values) # Animation function def frame(t): fig.clf() # Calculating time time_model = tw * (t + 1 ) # tw is write step, t is index of data file time_seconds = time_model / f0 # time dimension given by f0 time_hours = time_seconds / 3600 time_days = floor( time_seconds / 86400 ) # Floor function is to prevent rounding up in formatting time_months = time_seconds / 2.628e6 time_years = time_days / 365 # Animating title if (dimensions): time_stamp = ', {:02.0f} (days) {:02.0f} (hours)'.format( time_days, time_hours % 24) else: time_stamp = ', {:05.0f} (step)'.format(time_model) plt.title(title + time_stamp) # Animating contours field = velocity_grid[:, :, t] if (dimensions): field = field * ( f0 * L ) # Constant gives dimension, units dertermined by param file ax = plt.contourf(xx, yy, field, colorange, cmap=cm.seismic) # Plot details if (dimensions): plt.xlabel('x (m)') plt.ticklabel_format(axis='x', style='sci', scilimits=(0, 0)) #Need to sort out labels plt.ylabel('y (m)') plt.yticks([]) else: plt.xlabel("x'") plt.ylabel("y'") if (dimensions): cbar_unit = 'ms$^{-1}$' else: cbar_unit = '' cbar = plt.colorbar( format='%.1e', label=cbar_unit) # assumed units, check matches param file animation = ani.FuncAnimation(fig, frame, range(start, end, step), interval=interval * 1e+3, blit=False) animation.save(datapath + '/' + field_name + '-animation.gif', writer=writer)
import numpy as np from matplotlib import animation import h5py import argparse import matplotlib.pyplot as plt mywriter = animation.ImageMagickFileWriter() plt.rcParams['image.cmap'] = 'RdBu_r' parser = argparse.ArgumentParser( description='animate a field from dedalus output') parser.add_argument('folder', type=str, help='top level folder to look in') parser.add_argument('sim_name', type=str, help='simulation name in dedalus file structure') parser.add_argument('-f', '--field', type=str, dest='field_to_animate') parser.add_argument('-o', '--outfile', type=str, dest='outfile') args = parser.parse_args() # get these from args folder = args.folder sim_name = args.sim_name field_to_animate = args.field_to_animate filepath = folder + "/" + sim_name + "_s1/" + sim_name + "_s1_p0.h5" data = h5py.File(filepath, "r") #te = data['tasks']['total e profile'][:] #te_1 = data['tasks']['total e'][:] z = data['scales/z/1.0'][:] t = data['scales']['sim_time'][:] x = data['scales/x/1.0'][:]
def __init__(self, quads, quad, display_obstacles=False, plot_sim_trail=False, plot_quad_trail=False, save=False): self.quads = quads self.quad = quad self.display_obstacles = display_obstacles self.plot_sim_trail = plot_sim_trail self.plot_quad_trail = plot_quad_trail self.fig = plt.figure() self.ax = self.fig.add_subplot(1, 1, 1, projection='3d') self.fig.tight_layout(rect=[0, 0, 1, 0.97]) #self.ax_graph = self.fig.add_subplot(2,1,2) self.ax.set_xlim3d([0.0, 4.0]) self.ax.set_xlabel('X') self.ax.set_ylim3d([0.0, 4.0]) self.ax.set_ylabel('Y') self.ax.set_zlim3d([0, 4.0]) self.ax.set_zlabel('Z') self.t = 1 self.ax.set_title('Quadcopter Simulation') # Store points for trails, if enabled self.x, self.y, self.z = [], [], [] # Create definitions for actual trail, and simulated trails self.trail, = self.ax.plot([], [], [], '--', c='blue', markersize=2) self.sim_trail, = self.ax.plot([], [], [], '.', c='red', markersize=2, markevery=4) '''bounds = self.quad.get_bounds(self.t, 0.01) xs = bounds[:, 0] ys = bounds[:, 4] zs = bounds[:, 8] p1 = np.array([xs, ys, zs])[:, 0] p2 = np.array([xs, ys, zs])[:, 1] self.prism = self.ax.add_collection3d(Poly3DCollection(self.plot_prism(p1, p2), color='green', alpha=.25)) self.prism_lines = self.ax.add_collection3d(Line3DCollection(self.plot_prism(p1, p2), color='green', linestyles='--', linewidths=1)) self.points = self.ax.scatter(xs, ys, zs, s=6, c='black')''' self.artists = [self.sim_trail, self.trail] if self.display_obstacles: xs, ys, zs = np.indices((4, 1, 5)) voxel = (xs < 4) & (ys < 0.5) & (zs < 5) self.ax.voxels(voxel, facecolors='red', edgecolor='k') for key in self.quads: self.quads[key]['l1'], = self.ax.plot([], [], [], color='blue', linewidth=2) self.quads[key]['l2'], = self.ax.plot([], [], [], color='red', linewidth=2) self.quads[key]['hub'], = self.ax.plot([], [], [], marker='o', color='green', markersize=6) self.artists.append(self.quads[key]['l1']) self.artists.append(self.quads[key]['l2']) self.artists.append(self.quads[key]['hub']) self.artists = tuple(self.artists) self.ax.view_init(elev=30, azim=10) self.ani = animation.FuncAnimation(self.fig, self.update, frames=400, init_func=None, interval=5, blit=False) if save: # Interval : Amount of time, in ms between generated frames # Frames: Number of frames to produce # FPS: 1/(interval*0.001) -> multiple by number of seconds needed for number of frames writer = animation.ImageMagickFileWriter(fps=1 / (5 * 0.001)) self.ani.save('test.gif', writer=writer) else: plt.show() os._exit(0)
def make_multi_star_animation(te, dx, dy, r, tau, star, d_star, savename='eclipse_multi_star.gif'): ''' This function creates a plot that shows the eclipsing system The relevant light curve, and the corresponding gradient of the light curve. Parameters ---------- te : float duration of the eclipse. dx : array_like (1-D) Array containing all the circle centres shifted by dx in the x direction. dy : array_like (1-D) Array containing all the circle centres shifted by dy in the y direction. r : array_like (1-D) array containing the radii of the rings to be simulated. these should be in increasing order and should not contain 0. tau : array_like (1-D) array containing the opacity of the rings specified above. values should be between 0 and 1 and the array should have the same length as r. d_star : array_like (1-D - len(d_star) <= 3) size of the star in days in ascending order. plot_data : array_like (2-D) array consisting of 4 vectors. [0] = time, [1] = light curve if the star was a laser beam, [2] = the light curve with a finite sized star, [3] = the gradients measured. animate_plot : boolean determines whether or not to make an animation of the transit Returns ------- Plot or Animation Notes ----- This function only works for a single (dx, dy) point ''' print('setting up figure') # disk parameters a, b, tilt, inc = find_ellipse_parameters(te, dx, dy) ##### creating the figure ##### # title with all the information pertaining to the disk system title1 = 'Eclipse of a Circumplanetary Disk \n' #title2 = 'Star - $R_{*}$ = %.2f days, b = %.2f days \n'%(d_star/2.,dy[0]) # needed later title2 = 'Disk - $i$ = %.2f$^o$, $\\phi$ = %.2f$^o$ \n' % (inc, tilt) title3 = '$R_{disk}$ = ' + str(np.round(r, 2)) + ' days \n ' title4 = '$\\tau$ = ' + str(np.round(tau, 2)) title = title1 + title2 + title3 + title4 #creating the figure fig = plt.figure(figsize=(15, 8)) fig.suptitle(title) n = min(len(d_star), 3) # create axes axs = np.zeros((3, 0)) if n >= 1: ax0a = plt.subplot2grid((3, n), (0, 0)) #,rowspan=2) ax1a = plt.subplot2grid((3, n), (1, 0), sharex=ax0a) ax2a = plt.subplot2grid((3, n), (2, 0), sharex=ax0a) axsa = np.array([ax0a, ax1a, ax2a]) axs = np.concatenate((axs, axsa[:, None]), 1) if n >= 2: ax0b = plt.subplot2grid((3, n), (0, 1)) #,rowspan=2) ax1b = plt.subplot2grid((3, n), (1, 1), sharex=ax0b) ax2b = plt.subplot2grid((3, n), (2, 1), sharex=ax0b) axsb = np.array([ax0b, ax1b, ax2b]) axs = np.concatenate((axs, axsb[:, None]), 1) if n >= 3: ax0c = plt.subplot2grid((3, n), (0, 2)) #,rowspan=2) ax1c = plt.subplot2grid((3, n), (1, 2), sharex=ax0c) ax2c = plt.subplot2grid((3, n), (2, 2), sharex=ax0c) axsc = np.array([ax0c, ax1c, ax2c]) axs = np.concatenate((axs, axsc[:, None]), 1) # open lists for the animation plot_data = [] all_stars = [] lims = [[-np.amax(d_star), np.amax(d_star)], [-0.05, 1.05], [-0.05, 1.05]] ylabels = ['y [days]', 'normalised flux [-]', 'gradient [-]'] # set up for animation for j in range(n): # create ring patches rings = vector_rings(r, tau, inc, tilt, dy) # getting light curve data _, _, data = get_light_curve(te, dx, dy, star, d_star[j], r, tau) # introducing a skip factor to reduce equalize the number of frames if j == 0: frame_times = np.linspace(data[0, 0], data[0, -1], 101) frame_indices = frame_selection(data[0], frame_times) ani_data = data[:, frame_indices] # appending to plot_data plot_data.append(ani_data) time = ani_data[0] stars = [ patches.Circle((x, 0), d_star[j] / 2., color='g', alpha=0.7) for x in time ] all_stars.append(stars) for i in range(3): # setting limits axs[i, j].set_xlim(time[0], time[-1]) axs[i, j].set_ylim(lims[i]) # setting labels if j == 0: axs[i, j].set_ylabel(ylabels[i]) if i == 2: axs[i, j].set_xlabel('time [days]') # adding vector graphics if i == 0: axs[i, j].set_aspect('equal') axs[i, j].set_adjustable('box') for ring in rings: axs[i, j].add_patch(ring) xy_rect = (time[0], -d_star[j] / 2.) w_rect = time[-1] - time[0] star_path = patches.Rectangle(xy_rect, w_rect, d_star, color='g', alpha=0.5) axs[i, j].axhline(y=0, color='k', ls='--') axs[i, j].set_title('$D_*$ = %.2f days' % d_star[j]) def animate(f): ''' This function produces the animation for the plot. ''' print('frame %i/101 \r' % f), # clearing the plots of lines for j in range(n): if f == 0: for artist in axs[1, j].lines + axs[1, j].collections: artist.remove() for artist in axs[2, j].lines + axs[2, j].collections: artist.remove() try: all_stars[j][f - 1].remove() all_stars[j][f - 1].remove() except: None # moving the star Star = all_stars[j][f] axs[0, j].add_artist(Star) # transmission of rings axs[1, j].plot(plot_data[j][0, :f], plot_data[j][1, :f], 'r-') # light curve axs[1, j].plot(plot_data[j][0, :f], plot_data[j][2, :f], 'g-') # gradient curve axs[2, j].plot(plot_data[j][0, :f], plot_data[j][3, :f], 'g-') print('creating animation') ani = animation.FuncAnimation(fig, animate, interval=5, repeat_delay=250) writer = animation.ImageMagickFileWriter(fps=20) print('saving animation') ani.save(savename, writer=writer) return None
def inund_calc(outputfile): print("Animating inundation...\n") import struct import numpy as np import PIL import sys import matplotlib matplotlib.use('Agg') from matplotlib import pyplot as plt import scipy.stats as st import matplotlib.animation as animation fps = 5 mapdir = "./config/" nrow, ncol = 300, 303 nofpix = ncol * nrow skip = 3 thresh = 0.7 print("reading inundation map parameters...") ncdata = Dataset(mapdir + "./m_arc.nc") m = ncdata.variables['Band1'][:] m[m < 0] = 1000 ncdata = Dataset(mapdir + "./sigma_arc.nc") sigma = ncdata.variables['Band1'][:] ncdata = Dataset(mapdir + "./units_arc.nc") units = ncdata.variables['Band1'][:] units = units.astype("float") units[m <= 0] = np.nan units[sigma <= 0] = np.nan codes = { 1: "Panhandle", 2: "Thaoge", 3: "Xudum", 4: "Boro", 5: "Khwai", 6: "Nqoga-1a", 7: "Selinda", 8: "Nqoga-2a", 9: "Mboroga" } unitsf = units.flatten() mf = m.flatten() sigmaf = sigma.flatten() print("done\n") cellnames, cellvalues = mergecells(gl.fin_sa_end) dates = pd.to_datetime(gl.recdate) sa = pd.DataFrame(cellvalues.T, index=dates, columns=cellnames) nts = sa.shape[0] print("read", nts, "time steps") print("will skip", skip, "time steps") print("done\n") print("processing...") fig, pl = plt.subplots(figsize=(5, 5)) #preparing empty frame temp = np.zeros_like(units).astype(float) temp[:] = 0 im = pl.imshow(temp, cmap=plt.cm.RdBu) #plt.show() #preparing canvas pl.set_yticks([]) pl.set_xticks([]) tx = pl.text(0.7, 0.9, sa.index.strftime('%Y %B')[0], transform=pl.transAxes) def plotflood(ts): if ts % 10 == 0: print("ts=" + str(ts)) inu = sa.iloc[ts, :] amap = np.zeros_like(mf).astype(float) amap[:] = np.nan for key in codes.keys(): area = inu[codes[key]] sel = np.where(unitsf == key)[0] for x in sel: prob = st.norm.cdf(area, mf[x], sigmaf[x]) if thresh > 0: if prob > thresh: amap[x] = 1 else: amap[x] = prob amap = np.flipud(amap.reshape(nrow, ncol)) tx.set_text(sa.index.strftime('%Y %B')[ts]) im.set_array(amap) return im, ani = animation.FuncAnimation(fig, plotflood, range(skip, nts)) writer = animation.ImageMagickFileWriter(fps=fps) ani.save(outputfile, writer=writer) print("done")
def generate_logo(animateLogo=False, animateInterval=200, saveLogo=None, showLogo=True, dpi=300, namd_start_angle=60.0): ''' Generate the Hefei-NAMD logo. ''' figure = plt.figure(figsize=(3.0, 4.0)) ax = plt.subplot() ax.set_aspect('equal') ax.axis('off') ############################################################ R0 = 1.0 C0 = Circle( (0.0, 0.0), radius=R0, facecolor='k', alpha=0.7, ) C1 = Circle((0.0, 0.0), radius=0.55 * R0, facecolor='w') ax.add_patch(C0) ax.add_patch(C1) ############################################################ MOLCOLORS = ['r', 'b', 'b'] R, P = get_molecule_positions(theta=-10) for ii in range(3): cc = Circle(P[ii], radius=R[ii], facecolor=MOLCOLORS[ii], alpha=0.6) ax.add_patch(cc) R, P = get_molecule_positions(theta=-120, shrink=0.15) P += np.array([-0.2, -0.2]) for ii in range(3): cc = Circle(P[ii], radius=R[ii], facecolor=MOLCOLORS[ii], alpha=0.5) ax.add_patch(cc) R, P = get_molecule_positions(theta=120, shrink=0.1) P += np.array([0.2, -0.2]) for ii in range(3): cc = Circle(P[ii], radius=R[ii], facecolor=MOLCOLORS[ii], alpha=0.4) ax.add_patch(cc) ############################################################ NAMD = [x.upper() for x in 'namd'] if animateLogo: namd_rot = [] for angle in range(0, 360, 10): start_angle = angle / 180. * np.pi tmp = [] for ii in range(4): tc = np.exp(1j * (start_angle + ii * np.pi / 2)) c1 = Circle( (tc.real, tc.imag), radius=0.4, facecolor='white', # alpha=0.9 ) ax.add_patch(c1) c2 = Circle((tc.real, tc.imag), radius=0.32, facecolor='red', alpha=0.5) ax.add_patch(c2) c3 = ax.text( tc.real, tc.imag - 0.05, NAMD[ii], ha="center", va="center", fontsize=52, # family='monospace', color='white', fontweight='bold', transform=ax.transData, fontname='Cooper Black', # bbox=dict(boxstyle='round', facecolor='wheat', alpha=0.5) ) tmp += [c1, c2, c3] namd_rot.append(tmp) else: start_angle = namd_start_angle / 180. * np.pi for ii in range(4): tc = np.exp(1j * (start_angle + ii * np.pi / 2)) c1 = Circle( (tc.real, tc.imag), radius=0.4, facecolor='white', # alpha=0.9 ) ax.add_patch(c1) c2 = Circle((tc.real, tc.imag), radius=0.32, facecolor='red', alpha=0.5) ax.add_patch(c2) c3 = ax.text( tc.real, tc.imag - 0.05, NAMD[ii], ha="center", va="center", fontsize=52, # family='monospace', color='white', fontweight='bold', transform=ax.transData, fontname='Cooper Black', # bbox=dict(boxstyle='round', facecolor='wheat', alpha=0.5) ) ############################################################ ax.plot([-1.4, 1.4], [-1.45, -1.45], 'k-', lw=5.0) ############################################################ TEXT = 'HEFEI' TPOS = np.linspace(-1.1, 1.1, 5, endpoint=True) TROT = [-19.05462068, 1.69593734, -11.93570325, -0.39501574, 22.31639076] # TROT = [-16.59700324, -7.07637502, 29.74676562, 7.06633301, 22.90883817] # TROT = np.random.uniform(-1, 1, 5) * 30 # print(TROT) TCLR = plt.rcParams['axes.prop_cycle'].by_key()['color'] for ii in range(5): h = TPOS[ii] v = -2.10 + np.sin(ii * np.pi / 2) * 0.2 # v = -1.95 T = plt.text( h, v, TEXT[ii], ha="center", va="center", fontsize=52, # family='monospace', color='white', alpha=0.95, rotation=TROT[ii], fontweight='bold', transform=ax.transData, fontname='Cooper Black', # bbox=dict(pad=0.1, lw=0.0, boxstyle='circle', facecolor='green', alpha=0.6) ) # ax.plot([h,], [v], marker='o', ms=5) # box = T.get_window_extent().inverse_transformed(ax.transData) # box_w = box.x1 - box.x0 # box_h = box.y1 - box.y0 # RR = Rectangle( # (box.x0, box.y0 + 0.1), box_w, box_h, # facecolor='green' # ) # ax.add_patch(RR) cc = Circle( (h, v + 0.05), radius=0.3, # facecolor='green', facecolor=TCLR[ii], alpha=0.6) ax.add_patch(cc) ax.set_xlim(-1.5, 1.5) ax.set_ylim(-2.55, 1.4) plt.tight_layout(pad=0.1) if animateLogo: ani = animation.ArtistAnimation(figure, namd_rot, interval=200, blit=True, repeat_delay=0) movieWrite = animation.ImageMagickFileWriter(fps=12) movieWrite.setup(fig=figure, outfile=saveLogo) ani.save(saveLogo, writer=movieWrite, dpi=120) else: plt.savefig(saveLogo, dpi=dpi) if showLogo: plt.show()
def build_gif(imgs, interval=0.1, dpi=72, save_gif=True, saveto='animation.gif', show_gif=False, cmap=None): """Take an array or list of images and create a GIF. Parameters ---------- imgs : np.ndarray or list List of images to create a GIF of interval : float, optional Spacing in seconds between successive images. dpi : int, optional Dots per inch. save_gif : bool, optional Whether or not to save the GIF. saveto : str, optional Filename of GIF to save. show_gif : bool, optional Whether or not to render the GIF using plt. cmap : None, optional Optional colormap to apply to the images. Returns ------- ani : matplotlib.animation.ArtistAnimation The artist animation from matplotlib. Likely not useful. """ imgs = np.asarray(imgs) h, w, *c = imgs[0].shape fig, ax = plt.subplots(figsize=(np.round(w / dpi), np.round(h / dpi))) fig.subplots_adjust(bottom=0) fig.subplots_adjust(top=1) fig.subplots_adjust(right=1) fig.subplots_adjust(left=0) ax.set_axis_off() mpl.verbose.set_level("helpful") if cmap is not None: axs = list(map(lambda x: [ax.imshow(x, cmap=cmap)], imgs)) else: axs = list(map(lambda x: [ax.imshow(x)], imgs)) ani = animation.ArtistAnimation(fig, axs, interval=interval * 1000, repeat_delay=0, blit=False) if save_gif: try: writer = animation.ImageMagickFileWriter() ani.save(saveto, writer=writer, dpi=dpi) except: print( 'You do not have imagemagick installed.\n\nOn OSX ' + 'you can install this by first installing homebrew: ' + 'http://brew.sh\nThen run: "brew install imagemagick".\n' + 'Windows users can obtain a binary installation here: ' + 'https://www.imagemagick.org/script/binary-releases.php\n' + 'And Linux users should be able to install imagemagick using ' + 'their package manager, e.g.: sudo apt-get install imagemagick.' ) if show_gif: plt.show() return ani