def __init__(self, parent, controller):
tk.Frame.__init__(self, parent)
self.configure(bg=BG_COLOR)
self.trends = Figure(figsize=(5, 5), dpi=100)
self.a = self.trends.add_subplot(111)
canvas = FigureCanvasTkAgg(self.trends, self)
canvas.show()
canvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=1)
toolbar = NavigationToolbar2TkAgg(canvas, self)
toolbar.update()
canvas._tkcanvas.pack(side=tk.BOTTOM, fill=tk.BOTH, expand=1)
self.animation = FuncAnimation(self.trends, self.animate, 5000)
python类animation()的实例源码
def initialize(self):
self.fig = plt.figure()
self.axes_dict = self.create_fig(self.fig)
for plot_key in self.plot_layers.keys():
plot_layer = self.plot_layers[plot_key]
if plot_key not in self.axes_dict:
raise KeyError("No axis created for plot %s" % plot_key)
plot_layer.create_fig(self.fig, self.axes_dict[plot_key])
# matplotlib.animation.Animation._blit_draw = _blit_draw
self.anim = animation.FuncAnimation(self.fig, self.update_func, init_func=self.init_func, frames=None,
interval=1000 / self.fps, blit=True)
print("show")
plt.ion()
plt.show()
print("continue")
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 main():
print('plotting data...')
analogPlot = AnalogPlot(200)
# set up animation
fig = plt.figure()
ax = plt.axes(xlim=(0, 200), ylim=(-1000, 8000))
a0, = ax.plot([], [])
a1, = ax.plot([], [])
anim = animation.FuncAnimation(fig, analogPlot.update,
fargs=(a0, a1),
interval=40,
frames=300,
blit=True)
plt.show()
# anim.save('animation.mp4', fps=30,
# extra_args=['-vcodec', 'libx264'])
print('exiting.')
# call main
def __init__(self, sim, fig, grid=[3, 3], display_interval=100, type_to_color=None):
"""
Create new animation showing results of molecular dynamics simulation
:param sim: simulation instance
:param fig: matplotlib figure
:param grid: size of the plot grid, i.e. how many spaces where plots can be positioned to
:param display_interval: how many time steps to run before a new animation frame is drawn
:param type_to_color: array of matplotlib colors ith same length as there are particle types in the simulation,
mapping each particle type to a color
"""
self._sim = sim
self._fig = fig
self._display_interval = display_interval
self._animators = []
self._grid_spec = matplotlib.gridspec.GridSpec(*grid)
self._type_to_color = type_to_color
self._frame_callbacks = []
if not self._type_to_color:
self._type_to_color = get_default_particle_colors(sim.nr_of_atom_types)
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 theta_anim(self):
#
# Animate the contour plot from above by varying theta from 0 to 2*pi
#
self.theta = 0
x,y,z = self.location_contours([0.2, 0.2, 0.2, self.theta])
self.fig = plt.figure()
self.im = plt.imshow(z, interpolation='bilinear', origin='lower', cmap=cm.inferno)
CBI = plt.colorbar(self.im, orientation='horizontal', shrink=0.8)
plt.title('Contour Plot - Q')
ani = animation.FuncAnimation(self.fig, self.update_theta, interval=50, blit=False)
plt.show()
def theta_gif(self):
#
# Create an animated gif of the contour plot from above by varying theta from 0 to pi
#
self.theta = 0
x,y,z = self.location_contours([0.2, 0.2, 0.2, self.theta])
self.fig = plt.figure()
self.im = plt.imshow(z, interpolation='bilinear', origin='lower', cmap=cm.inferno)
CBI = plt.colorbar(self.im, orientation='horizontal', shrink=0.8)
plt.xlabel('X %')
plt.ylabel('Y %')
ani = animation.FuncAnimation(self.fig, self.update_theta, frames=np.arange(0,20), interval=200, blit=False)
ani.save('figures/theta.gif', dpi=80, writer='imagemagick')
def sensor_anim(self, theta=0):
#
# Animate the contour plot by changing sensor values and holding
# the angle fixed at theta.
#
self.theta = theta
self.sensor = 0.0
x,y,z = self.location_contours([0,0,0, self.theta])
self.fig = plt.figure()
self.im = plt.imshow(z, interpolation='bilinear', origin='lower', cmap=cm.inferno)
CBI = plt.colorbar(self.im, orientation='horizontal', shrink=0.8)
ani = animation.FuncAnimation(self.fig, self.update_sensor, interval=50, blit=False)
plt.show()
def __init__(self, t, fig, axim, tracker, occ, pt_xz, pt_zy, body, bodies,
occultors, interval = 50, gifname = None, xy = None,
quiet = False):
'''
'''
self.t = t
self.fig = fig
self.axim = axim
self.tracker = tracker
self.occ = occ
self.pt_xz = pt_xz
self.pt_zy = pt_zy
self.body = body
self.bodies = bodies
self.occultors = occultors
self.xy = xy
self.pause = True
self.animation = animation.FuncAnimation(self.fig, self.animate,
frames = 100,
interval = interval,
repeat = True)
# Save?
if gifname is not None:
self.pause = False
if not gifname.endswith('.gif'):
gifname += '.gif'
if not quiet:
print("Saving %s..." % gifname)
self.animation.save(gifname, writer = 'imagemagick',
fps = 20, dpi = 150)
self.pause = True
# Toggle button
self.axbutton = pl.axes([0.185, 0.12, 0.1, 0.03])
self.button = Button(self.axbutton, 'Play', color = 'lightgray')
self.button.on_clicked(self.toggle)
def toggle(self, event):
'''
Pause/play the animation. Unfortunately I haven't been able to
figure out how to freeze the animation so that it resumes at the
same frame it was paused on...
'''
if self.pause:
self.button.label.set_text('Pause')
else:
self.button.label.set_text('Play')
self.pause ^= True
def animate(self, j):
'''
Play frame `j` of the animation.
'''
if not self.pause:
# Normalize the time index
j = int(j * len(self.t) / 100.)
# Time tracker
self.tracker.set_xdata(self.bodies[0].time_hr[self.t[j]])
# Occultor images
x0 = self.body.x_hr[self.t[j]]
y0 = self.body.y_hr[self.t[j]]
for k, occultor in enumerate(self.occultors):
if self.xy is None:
xo, yo = occultor.x_hr[self.t[j]] - x0, \
occultor.y_hr[self.t[j]] - y0
else:
xo, yo = self.xy(occultor.x_hr[self.t[j]] - x0,
occultor.y_hr[self.t[j]] - y0)
self.occ[k].center = (xo / self.body._r, yo / self.body._r)
# BODY orbits
for k, b in enumerate(self.bodies):
self.pt_xz[k].set_xdata(b.x_hr[self.t[j]])
self.pt_xz[k].set_ydata(b.z_hr[self.t[j]])
self.pt_zy[k].set_xdata(b.z_hr[self.t[j]])
self.pt_zy[k].set_ydata(b.y_hr[self.t[j]])
def initialize(self):
self.fig = plt.figure()
self.axes_dict = self.create_fig(self.fig)
for plot_key in self.plot_layers.keys():
plot_layer = self.plot_layers[plot_key]
if plot_key not in self.axes_dict:
raise KeyError("No axis created for plot %s" % plot_key)
plot_layer.create_fig(self.fig, self.axes_dict[plot_key])
# matplotlib.animation.Animation._blit_draw = _blit_draw
self.anim = animation.FuncAnimation(self.fig, self.update_func, init_func=self.init_func, frames=None,
interval=1000 / self.fps, blit=True)
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 __init__(self, parent, status, title):
ttk.Frame.__init__(self, parent)
self.status = status
self.canvas = FigureCanvasTkAgg(status.figure, self)
self.canvas.show()
self.canvas.get_tk_widget().pack(side=tk.BOTTOM, fill=tk.BOTH, expand=True)
self.animation = animation.FuncAnimation(status.figure, lambda i : status.update_plots(i), interval=1000)
def animation(agents, function, lb, ub, sr=False):
side = np.linspace(lb, ub, (ub - lb) * 5)
X, Y = np.meshgrid(side, side)
Z = np.array([np.array([function([X[i][j], Y[i][j]])
for j in range(len(X))])
for i in range(len(X[0]))])
fig = plt.figure()
plt.axes(xlim=(lb, ub), ylim=(lb, ub))
plt.pcolormesh(X, Y, Z, shading='gouraud')
plt.colorbar()
x = np.array([j[0] for j in agents[0]])
y = np.array([j[1] for j in agents[0]])
sc = plt.scatter(x, y, color='black')
plt.title(function.__name__, loc='left')
def an(i):
x = np.array([j[0] for j in agents[i]])
y = np.array([j[1] for j in agents[i]])
sc.set_offsets(list(zip(x, y)))
plt.title('iteration: {}'.format(i), loc='right')
ani = matplotlib.animation.FuncAnimation(fig, an, frames=len(agents) - 1)
if sr:
ani.save('result.mp4')
plt.show()
ParticleFilterVisualizer.py 文件源码
项目：Particle-Filter-Visualizer
作者: ChrisShepherd81
项目源码
文件源码
阅读 26
收藏 0
点赞 0
评论 0
def main(argv):
dataFolder = ''
particlesFile = ''
numberOfParticles = 0
outputFile = "animation"
usage = 'ParticleFilterVisualizer.py -f <dataFolder> -p <particleFile> -n <numberOfParticles> [-o <outputFileName>]'
try:
opts, args = getopt.getopt(argv,"hf:p:n:o:",["dataFolder=","particleFile=","numberParticles=" ,"outPutFile="])
except getopt.GetoptError:
print(usage)
sys.exit(2)
if len(opts) is 0:
print(usage)
sys.exit()
for opt, arg in opts:
if opt == '-h':
print(usage)
sys.exit()
elif opt in ("-f", "--dataFolder"):
dataFolder = arg
elif opt in ("-p", "--particleFile"):
particlesFile = arg
elif opt in ("-n", "--numberOfParticles"):
numberOfParticles = arg
elif opt in ("-o", "--outputFile"):
outputFile = arg
else:
print(usage)
sys.exit(2)
plotData(dataFolder, particlesFile, numberOfParticles, outputFile)
def get_animation_object(self, **kwargs):
"""Returns matplotlib FuncAnimation object - use this e.g. to store animation as video"""
self.__update()
return animation.FuncAnimation(self._fig, self.__update, **kwargs)
def run(self, final_frame_name=None, dpi=300):
"""
Starts the visualization process.
If the property `out_filename` is set, the visualization is saved as a
video to the disk; if not, the animation is displayed on screen.
Please refer to documentation of `add_LPU`, `add_plot`
and the properties of this class on how to configure the visualizer
before calling this method. An example can be found in the class doc
string.
Parameters
----------
final_frame_name : str, optional
If specified, the final frame of the animation is saved
to disk.
dpi : int, default=300
Resolution at which final frame is saved to disk if
`final_frame_name` is specified.
Notes
-----
If `update_interval` is set to 0 or None, it will be replaced by the
index of the final time step. As a result, the visualizer will only
generate and save the final frame if `final_frame_name` is set.
"""
self.final_frame_name = final_frame_name
self._initialize()
if not self._update_interval:
self._update_interval = self._maxt
self._t = self._maxt
if self._update_interval == -1:
self._update_interval = max(np.asarray(self._dts.values()))*50
for _ in np.arange(self._t,self._maxt*(1+np.finfo(float).eps),
self._update_interval):
self._update()
if final_frame_name is not None:
self.f.savefig(final_frame_name, dpi=dpi)
if self.out_filename:
self._close()
def update_interval(self):
"""
Update interval (in unit of time same as dt in the h5 files) for the animation.
"""
return self._update_interval
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 make_aia_animation(aia, start_time: u.s, stop_time: u.s, root_dir, figsize=None, norm=None, fontsize=14, **kwargs):
"""
Build animation from a series of synthesized AIA observations
"""
with h5py.File(aia.counts_file, 'r') as hf:
reference_time = u.Quantity(hf['time'], hf['time'].attrs['units'])
start_index = np.where(reference_time == start_time)[0][0]
stop_index = np.where(reference_time == stop_time)[0][0]
fig_format = os.path.join(root_dir, f'{aia.name}', '{}', 'map_t{:06d}.fits')
fig, ims = plot_aia_channels(aia, start_time, root_dir, figsize=figsize, norm=norm, fontsize=fontsize,
use_with_animation=True)
def update_fig(i):
for channel in aia.channels:
tmp = Map(fig_format.format(channel['name'], i))
ims[channel['name']].set_array(tmp.data)
fig.suptitle(r'$t={:.0f}$ {}'.format(reference_time[i].value, reference_time.unit.to_string()),
fontsize=fontsize)
return [ims[k] for k in ims]
animator_settings = {'interval': 50, 'blit': True}
animator_settings.update(kwargs.get('animator_settings', {}))
animation = matplotlib.animation.FuncAnimation(fig, update_fig, frames=range(start_index, stop_index),
**animator_settings)
return animation
def animate(self, act_fn, nsteps, file_name, rate=1.5, verbose=False):
"""
Save an animation to an mp4 file.
"""
plt.figure(0)
# run sim loop
o = self.reset()
file_path = "/".join(file_name.split("/")[0:-1])
temp_name = join(file_path, "temp_0.png")
# generate .pngs
self.save_image(temp_name)
removed = 0
for i in range(nsteps):
a = act_fn(o)
o, r, done, info = self.step(a)
temp_name = join(file_path, "temp_" + str(i + 1) + ".png")
self.save_image(temp_name)
removed += info['removed']
if verbose:
print(r, info)
if done:
break
if verbose:
print("Total removed:", removed)
# use ffmpeg to create .pngs to .mp4 movie
ffmpeg_cmd = "ffmpeg -framerate " + str(rate) + " -i " + join(
file_path, "temp_%d.png") + " -c:v libx264 -pix_fmt yuv420p " + file_name
call(ffmpeg_cmd.split())
# clean-up by removing .pngs
map(os.remove, glob.glob(join(file_path, "temp_*.png")))
def plot_2d_animation(input, mask, predictions):
rgb_image = np.concatenate((input, input, input), axis=0)
mask = np.concatenate((np.zeros_like(input), mask, predictions), axis=0)
# green = targets
# blue = predictions
# red = overlap
idxs = np.where(mask > 0.3)
rgb_image[idxs] = mask[idxs]
rgb_image = np.rollaxis(rgb_image, axis=0, start=4)
print rgb_image.shape
def get_data_step(step):
return rgb_image[step, :, :, :]
fig = plt.figure()
im = fig.gca().imshow(get_data_step(0))
def init():
im.set_data(get_data_step(0))
return im,
def animate(i):
im.set_data(get_data_step(i))
return im,
anim = animation.FuncAnimation(fig, animate, init_func=init,
frames=rgb_image.shape[1],
interval=20000 / rgb_image.shape[0],
blit=True)
def on_click(event):
global anim_running
if anim_running:
anim.event_source.stop()
anim_running = False
else:
anim.event_source.start()
anim_running = True
fig.canvas.mpl_connect('button_press_event', on_click)
try:
plt.show()
except AttributeError:
pass
def animation3D(agents, function, lb, ub, sr=False):
side = np.linspace(lb, ub, 45)
X, Y = np.meshgrid(side, side)
zs = np.array([function([x, y]) for x, y in zip(np.ravel(X), np.ravel(Y))])
Z = zs.reshape(X.shape)
fig = plt.figure()
ax = Axes3D(fig)
surf = ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap='jet',
linewidth=0, antialiased=False)
ax.set_xlim(lb, ub)
ax.set_ylim(lb, ub)
ax.zaxis.set_major_locator(LinearLocator(10))
ax.zaxis.set_major_formatter(FormatStrFormatter('%.02f'))
fig.colorbar(surf, shrink=0.5, aspect=5)
iter = len(agents)
n = len(agents[0])
t = np.array([np.ones(n) * i for i in range(iter)]).flatten()
b = []
[[b.append(agent) for agent in epoch] for epoch in agents]
c = [function(x) for x in b]
a = np.asarray(b)
df = pd.DataFrame({"time": t, "x": a[:, 0], "y": a[:, 1], "z": c})
def update_graph(num):
data = df[df['time'] == num]
graph._offsets3d = (data.x, data.y, data.z)
title.set_text(function.__name__ + " " * 45 + 'iteration: {}'.format(
num))
title = ax.set_title(function.__name__ + " " * 45 + 'iteration: 0')
data = df[df['time'] == 0]
graph = ax.scatter(data.x, data.y, data.z, color='black')
ani = matplotlib.animation.FuncAnimation(fig, update_graph, iter,
interval=50, blit=False)
if sr:
ani.save('result.mp4')
plt.show()
