def plot_state_probs(state_probs_t, energy_t, system_size, interaction_shape, radius, alpha, path):
states = np.array(get_states_str(system_size))
fig = plt.figure(figsize=(9, 12))
plt.title('N = {}, {}, radius = {}, alpha = {}'.format(system_size, interaction_shape, radius, alpha))
plt.xlabel('State')
plt.ylabel('Probability')
camera = Camera(fig)
for t in range(0, len(state_probs_t)):
state_probs = state_probs_t[t]
max_prob = 0
ground_states = []
for state_id in range(len(state_probs)):
state_prob = state_probs[state_id]
if state_prob - max_prob > 1e-10:
ground_states = [state_id]
max_prob = state_prob
elif abs(state_prob - max_prob) < 1e-10:
ground_states.append(state_id)
plt.bar(range(len(state_probs)), state_probs)
plt.xticks(ground_states, labels=states[ground_states], rotation='vertical')
plt.ylim(bottom=0, top=1)
plt.text(0.05, 0.95, '<H> = {}'.format(round(energy_t[t], 1)), transform=fig.transFigure, verticalalignment='top')
# fig.tight_layout()
camera.snap()
animation = camera.animate()
animation.save('{}/state_probs_alpha_{}.gif'.format(path, alpha), writer = 'imagemagick')
plt.close()
# sample spin lattice in ground state
print(np.reshape(np.array([int(spin) for spin in states[ground_states[0]]]), system_size))
def create_CT_gif(img_slices,
gif_file,
vmin=0,
vmax=80,
x_axis=None,
y_axis=None):
fig, ax = plt.subplots(figsize=(10, 10))
ax.set_aspect('equal')
camera = Camera(fig)
for ii in range(img_slices.shape[0]):
if x_axis is not None and y_axis is not None:
cax = ax.pcolormesh(x_axis,
y_axis,
np.flipud(img_slices[ii, :, :]),
vmin=vmin,
vmax=vmax,
cmap=plt.get_cmap("Greys").reversed())
else:
cax = ax.pcolormesh(np.flipud(img_slices[ii, :, :]),
vmin=vmin,
vmax=vmax,
cmap=plt.get_cmap("Greys").reversed())
camera.snap()
animation = camera.animate()
animation.save(gif_file, writer='imagemagick')
def time_evolution_changing_lambda(lams, x, h, tau, niter, L, a=5):
interval = int(numpy.ceil(niter / len(lams)))
print("Generating states ...")
states = numpy.zeros((niter + 1, len(x)), dtype=complex)
states[0] = phi(0, x - a)
for n in range(niter):
Vm = V1D(lams[n // interval], x)
states[n][0] = 0
states[n][-1] = 0
states[n + 1] = implicit_scheme_step(states[n], tau, h, Vm)
print("Animating TASK 2 ...")
fig, ax = plt.subplots()
fig.suptitle("Task 2: $N=0, a={0}, \\lambda \\in {1}$".format(a, lams))
def animate(frame):
print("Animating TASK 2\t{0} | {1}".format(niter, frame + 1))
ax.clear()
ax.set_title("$\\lambda={}$".format(lams[frame // interval]))
ax.set_ylim(bottom=0, top=1.5)
ax.plot(x, numpy.abs(states[frame])**2)
animation = matplotlib.animation.FuncAnimation(fig,
animate,
frames=niter,
interval=5)
animation.save("naloga2_L{0}_a{1}.mp4".format(L, a))
def anim_to_html(anim):
if not hasattr(anim, '_encoded_video'):
with NamedTemporaryFile(suffix='.mp4') as f:
anim.save(f.name, fps=20, extra_args=['-vcodec', 'libx264'])
video = open(f.name, "rb").read()
anim._encoded_video = video.encode("base64")
return VIDEO_TAG.format(anim._encoded_video)
def anim_to_html(anim):
if not hasattr(anim, '_encoded_video'):
with NamedTemporaryFile(suffix='.mp4') as f:
anim.save(f.name, fps=20, extra_args=['-vcodec', 'libx264'])
video = open(f.name, "rb").read()
anim._encoded_video = video.encode("base64")
return VIDEO_TAG.format(anim._encoded_video)
def _save(self, animation):
print('Saving animation...this could take a while...')
name = "{}masses_{}modes.mp4".format(
self._beaded_string.number_of_beads,
str(self._beaded_string.normal_modes))
self._create_directory(ANIMATIONS_FOLDER)
full_path = path.join(ANIMATIONS_FOLDER, name)
animation.save(full_path,
savefig_kwargs={'facecolor': BACKGROUND_COLOR})
def main(param, name):
from matplotlib import animation as anim
import matplotlib.pyplot as plt
import sys
pc = Init(param)
removed, infected, tree_dist, rand, beta_dist, l_time_dist, l_time, run_time, sea_ind = [
pc.removed, pc.infected, pc.tree_dist, pc.rand, pc.beta_dist,
pc.survival_times, pc.life_time, pc.run_time, pc.sea_ind
]
cmap, norm, bounds = pc.Cmap()
fig, ax = plt.subplots()
im = ax.imshow(tree_dist + infected, clim=[0, 12], cmap=cmap)
plt.colorbar(im, boundaries=bounds, norm=norm)
ax.set_yticks([])
ax.set_xticks([])
ax.set_title('frame: 0')
def animate(i, Infected, Tree_dist, Removed, Beta_dist, L_time_dist, Param,
Rand, Plot_frame, Name, sea_ind):
print(i)
Infected_, Tree_dist_, Removed_ = pc.disease_algo(
i, Infected, Tree_dist, Removed, Beta_dist, L_time_dist, Param,
Rand)
Infected[:], Tree_dist[:], Removed[:] = Infected_, Tree_dist_, Removed_
plot_arr = Infected + Tree_dist + sea_ind + (Removed * 12)
im.set_array(plot_arr)
ax.set_title('frame: ' + str(i))
# Uncomment for single frame plots
#if i == 100 or i == 400:
#Plot_frame(i, pc, Arr=plot_arr, Cmap=cmap, Norm=norm, Bounds=bounds, Name=Name, sea_ind=sea_ind, mode='anim')
#if i == 1:
#np.save('dat', plot_arr)
#Plot_frame(i, pc, Arr=plot_arr, Cmap=cmap, Norm=norm, Bounds=bounds, Name=Name, sea_ind=sea_ind, mode='static')
if len(np.where(Infected > 0)[0]) == 0:
print('no infected left')
sys.exit()
else:
return im,
anim = anim.FuncAnimation(fig,
animate,
fargs=(infected, tree_dist, removed, beta_dist,
l_time_dist, param, rand, pc.plot_frame,
name, sea_ind),
frames=run_time,
interval=20,
blit=True)
anim.save('simulations/' + name + '.mp4',
fps=30,
extra_args=['-vcodec', 'libx264'])
return
def __animation_to_html(animation, fps):
if not hasattr(animation, 'encoded_video'):
with NamedTemporaryFile(suffix='.mp4') as f:
animation.save(f.name,
fps=fps,
extra_args=[
'-vcodec', 'libx264', '-pix_fmt', 'yuv420p',
'-profile:v', 'baseline', '-level', '3.0'
])
video = open(f.name, "rb").read()
animation.encoded_video = base64.b64encode(video).decode('ascii')
return VIDEO_TAG.format(animation.encoded_video)
def make_gif(self, data, nframes):
fig = plt.figure()
plt.xlim(-0.2, 0.2)
plt.xticks(np.linspace(-0.2, 0.2, 10))
hist = plt.hist(x=data[:, 0],
bins=20,
color='dodgerblue',
alpha=0.7,
rwidth=0.85)
animation = FuncAnimation(fig,
HistGif.update_hist,
nframes,
fargs=(data, ))
animation.save("test.gif", dpi=100, writer=self.writer)
def plot_spin_lattice(prob, spin_history, energy_history, interaction_shape, interaction_radius, system_size, path):
fig = plt.figure()
plt.title('N = {}, {}, radius = {}'.format(system_size, interaction_shape, interaction_radius))
camera = Camera(fig)
# plot 1 spin configuration per temperature
for t in range(0, len(spin_history), 1000):
x_up, y_up, x_down, y_down = get_spin_lattice(spin_history[t], prob)
plt.scatter(x_up, y_up, s=20**2, c='red')
plt.scatter(x_down, y_down, s=20**2, c='blue')
plt.text(0.05, 0.95, 'E = {}'.format(round(energy_history[t], 1)), transform=fig.transFigure, verticalalignment='top')
plt.gca().set_aspect('equal', adjustable='box')
camera.snap()
animation = camera.animate()
animation.save('{}/spin_lattice_radius_{}.gif'.format(path, interaction_radius), writer = 'imagemagick')
plt.close()
def main():
robot = Robot()
robot.velocity_command = 0.5
robot.velocity = 0.0
time = 0
fig, ax = plt.subplots()
ax.set_ylim(-.5, 2.5)
ax.set_xlim(-1, 1)
com, = plt.plot([0],[2.0], 'bo', label="CoM")
leg1, = plt.plot([], [], 'ro', label="foot1")
leg2, = plt.plot([], [], 'go', label="foot2")
text = plt.text(-0.9, 1.0, '')
plt.legend()
def update(frame):
if robot.time > 1.0:
robot.velocity_command = -1.0
robot.advance(0.02)
def height(leg):
if leg.state == LiftState.STANCE:
return 0.0
return 0.5
leg1.set_data([robot.legs[0].pos], [height(robot.legs[0])])
leg2.set_data([robot.legs[1].pos], [height(robot.legs[1])])
text.set_text(
("velocity={:.2f}\nswing_time:{:.2f}\n" +
"left time:{:.2f}\nright time:{:.2f}").format(
robot.velocity,
SWING_PERIOD_S,
robot.left_time,
robot.right_time,
))
print(f"{robot.time:6.3f} {robot}")
return [com, leg1, leg2, text]
animation = FuncAnimation(fig, update, blit=True, interval=30,
frames=np.arange(0, 160))
if len(sys.argv) > 1:
animation.save(sys.argv[1],
writer=matplotlib.animation.ImageMagickWriter(fps=20))
else:
plt.show()
def ANIM(t_S,gros_vecteur,nom_fichier):
fig = plt.figure(0)
camera = Camera(fig)
for i in range(round(len(t_S)/10)):
with plt.xkcd():
titles = 'time = '+str(np.round(t_S[i*10+9],2))+' s'
plt.imshow(np.flip(np.transpose(gros_vecteur[:,:,i*10+9]),0),extent=[0,1,0,1],cmap='coolwarm')
# plt.plot(0.71,.08,'rx')
# plt.plot(0.25,0.75,'o',color='purple')
# plt.plot(0.5,0.5,'o',color='blue')
plt.plot(0.5,0.5,'go')
plt.text(0.3,1.05,titles)
camera.snap()
print(i)
animation = camera.animate(interval = 150)
animation.save('freefall.gif')
def animation_to_html(animation):
"""Embeds animation in html."""
video_tag = """<video controls>
<source src="data:video/x-m4v;base64,{0}" type="video/mp4">
Your browser does not support the video tag.
</video>"""
if not hasattr(animation, '_encoded_video'):
with NamedTemporaryFile(suffix='.mp4') as f:
animation.save(
f.name,
fps=20,
extra_args=['-vcodec', 'libx264', '-pix_fmt', 'yuv420p'])
video = open(f.name, "rb").read()
animation._encoded_video = video.encode("base64")
return video_tag.format(animation._encoded_video)
def animate(x, states, filename, lam, h, interval_base=10):
print("Rendering animation ...")
fig, ax = plt.subplots()
plt.suptitle("($\\lambda = {0}$)".format(lam))
plt.xlabel(r"$x$")
plt.ylabel(r"$|\psi|^2$")
def animate_func(frame):
print("{0} | {1}".format(len(states), frame))
ax.clear()
ax.set_ylim(bottom=0, top=1)
ax.plot(x, numpy.abs(states[frame])**2 / (h**2))
animation = matplotlib.animation.FuncAnimation(fig,
animate_func,
frames=len(states),
interval=interval_base)
animation.save(filename + ".mp4")
def generate_hawkes(given_range,cell_division,max_intensity,T,num_frames,show_plot=True):
sthp = Spatio_temp_hawkes(given_range,cell_division,max_intensity,T)
sthp.simulate()
data=np.array(sthp.data)
if show_plot:
dic_list=[{'x_axis':[],'y_axis':[]} for frame in range(num_frames)]
for point in data:
frame_diff =int(T/num_frames)
ind = int(point[0]/frame_diff)
#print ind
dic_list[ind]['x_axis'].append(point[1])
dic_list[ind]['y_axis'].append(point[2])
frame_list = [DataFrame(dic) for dic in dic_list]
# First set up the figure, the axis, and the plot element we want to animate
fig = plt.figure()
plt.grid(True)
ax = plt.axes(xlim=(0, 100), ylim=(0, 100))
line, = ax.plot([], [], 'bo', ms=6)
# initialization function: plot the background of each frame
def init():
line.set_data([], [])
return line,
# animation function of dataframes' list
def animate(i):
line.set_data(frame_list[i]['x_axis'], frame_list[i]['y_axis'])
return line,
# call the animator, animate every 300 ms
# set number of frames to the length of your list of dataframes
anim = animation.FuncAnimation(fig, animate, frames=num_frames, init_func=init, interval=300, blit=True)
anim.save('../Self_Exciting_Process/space_time_Hawkes/Plots/space_time_Hawkes_simulation.mp4', fps=10, extra_args=['-vcodec', 'libx264'])
plt.show()
return data,sthp
def animate(x,
states,
filename,
lam,
h,
tau,
N,
interval_base=200,
interval_slow=500,
range_slow=None,
frames_slow=20):
print("Rendering animation ...")
fig, ax = plt.subplots()
plt.suptitle(
"Time evolution of anharmonic oscilator wave function\n($\\lambda = {0}, h = {1}, \\tau = {2}, N = {3}$)"
.format(lam, h, tau, N))
plt.xlabel(r"$x$")
plt.ylabel(r"$|\psi|^2$")
def animate_func(frame):
ax.clear()
ax.plot(x, numpy.abs(states[frame])**2)
def animate_func2(frame):
ax.clear()
ax.plot(x, numpy.abs(states[frame + range_slow])**2)
os.chdir("hw1_schroedinger-equation-spectrum-and-time-evolution/images/")
animation = matplotlib.animation.FuncAnimation(fig,
animate_func,
frames=len(states),
interval=interval_base)
animation.save(filename + ".html")
if range_slow is not None:
animation = matplotlib.animation.FuncAnimation(fig,
animate_func2,
frames=frames_slow,
interval=interval_slow)
animation.save(filename + "_slow.html")
def collatz_paths_gif(n,to_save="",filename='Collatz_Paths.gif'):
A = collatz_back(n)
A = collatz_sort_2(A)
A = collatz_sort_rev(A)
S = collatz_pathsnumber(A)
col = int(10/len(A))/10
fig = plt.figure("Collatz-Paths")
cam = Camera(fig)
for i in range(len(A[0])):
for j in range(len(A)):
plt.plot(range(1,i+2),A[j][:i+1],color=(j*col,j*col,j*col),marker='.',markersize=10)
plt.xticks(range(0,n+1,1))
plt.text(1,int(max(map(max,A))/3),'Number of Collatz-Paths: '+str(S[i]),fontsize=12)
plt.xlabel('Lenght of Collatz-Path')
plt.ylabel('Initial Value')
plt.title('Collatz-Paths',fontsize=16)
plt.grid(True)
cam.snap()
animation = cam.animate(interval=1500)
if to_save == "save":
animation.save(filename, writer = 'imagemagick')
plt.show()
def task2_extra3a():
N = 0
lam = 0
L = 10
h = 0.01
tau = 0.001
a = 3
x = numpy.linspace(-L, L, int(2 * L / h) + 1)
Vm = V1D(lam, x)
niter = 20000
states = numpy.zeros((niter + 1, len(x)), dtype=complex)
states[0] = phi(0, x - a)
initial = numpy.abs(states[0])**2
for n in range(niter):
states[n][0] = 0
states[n][-1] = 0
states[n + 1] = implicit_scheme_step(states[n], tau, h, Vm)
print("Animating TASK 2 ...")
fig, ax = plt.subplots()
fig.suptitle("Time evolution ($a = 3$)")
def animate(frame):
print("Animating TASK 2\t{0} | {1}".format(niter, frame + 1))
diff = (numpy.abs(states[frame])**2 - initial)
dist = numpy.sqrt(diff.dot(diff))
ax.clear()
ax.set_title("$d(\\psi(0), \\psi({0})) = {1}$".format(
frame, numpy.round(dist, decimals=5)))
ax.set_ylim(bottom=0, top=1)
ax.plot(x, initial, "k-", linewidth=1)
ax.plot(x, numpy.abs(states[frame])**2)
animation = matplotlib.animation.FuncAnimation(fig,
animate,
frames=niter,
interval=2)
animation.save("naloga2_L{0}_a{1}.mp4".format(L, a))
def bake(self, options):
figure = pyplot.figure(figsize=(16, 9))
pyplot.axis([-16 / 9, 16 / 9, -1, 1])
pyplot.axis('off')
axes = figure.axes[0]
figure.subplots_adjust(left=0,
bottom=0,
right=1,
top=1,
wspace=None,
hspace=None)
writer = matplotlib.animation.writers['ffmpeg'](
fps=options.frame_rate,
codec=options.codec,
bitrate=options.bitrate,
extra_args=options.extra_args)
directory = "output"
if not os.path.exists(directory):
os.makedirs(directory)
for i, scene in enumerate(self.scenes):
print("== Scene ", str(i), " ==")
for artist in scene.artists:
axes.add_artist(artist)
animation = scene.play(figure, options)
animation.save(directory + "/scene" + str(i) + ".mp4",
writer=writer,
dpi=options.dpi)
for artist in scene.artists:
artist.remove()
counts = 0
for i in range(no_trials):
x = random.uniform(0,1)
if x < prob_photon:
counts += 1
return counts
prob_photon = 3.0e-3 #probability of receiving a photon in interval (p --> 0)
no_trials = 1000 #number of trials per second (n --> inf)
repeats = 1000
results = [] #counts from each interval
results_sequence = [] #the list of results (for the animation)
random.seed()
for i in range(repeats):
results.append(counts(prob_photon, no_trials))
results_sequence.append(copy.copy(results))
def update_hist(frame_no, results_sequence):
plt.cla()
plt.hist(results_sequence[frame_no])
plt.xlim([0,8])
fig = plt.figure()
plt.xlim([0,8])
plt.hist(results_sequence[0], align = 'mid', bins = [0, 1, 2, 3, 4, 5, 6, 7, 8])
animation = animation.FuncAnimation(fig, update_hist, repeats, fargs=(results_sequence,), repeat = False)
animation.save('poisson_hist2.mp4', writer = 'ffmpeg', fps = 5)
def main(args):
"""Command-line driver to visualize survey scheduling and progress.
"""
# Set up the logger
if args.debug:
log = desiutil.log.get_logger(desiutil.log.DEBUG)
args.verbose = True
elif args.verbose:
log = desiutil.log.get_logger(desiutil.log.INFO)
else:
log = desiutil.log.get_logger(desiutil.log.WARNING)
# Freeze IERS table for consistent results.
desisurvey.utils.freeze_iers()
# Set the output path if requested.
config = desisurvey.config.Configuration()
if args.output_path is not None:
config.set_output_path(args.output_path)
if args.tiles_file is not None:
config.tiles_file.set_value(args.tiles_file)
# Look for the exposures file in the output path by default.
args.exposures = config.get_path(args.exposures)
# Initialize.
animator = Animator(args.exposures, args.start, args.stop, args.label,
args.scores)
log.info('Found {0} exposures from {1} to {2} ({3} nights).'.format(
animator.num_exp, args.start, args.stop, animator.num_nights))
animator.init_figure(args.nightly)
if args.expid is not None:
expid = animator.exposures['EXPID']
assert np.all(expid == expid[0] + np.arange(len(expid)))
if (args.expid < expid[0]) or (args.expid > expid[-1]):
raise RuntimeError(
'Requested exposure ID {0} not available.'.format(args.expid))
animator.draw_exposure(args.expid - expid[0], args.nightly)
save_name = args.save + '.png'
plt.savefig(save_name)
log.info('Saved {0}.'.format(save_name))
else:
nframes = animator.num_nights if args.nightly else animator.num_exp
iexp = [0]
def init():
return animator.artists
def update(iframe):
if (iframe + 1) % args.log_interval == 0:
log.info('Drawing frame {0}/{1}.'.format(iframe + 1, nframes))
if args.nightly:
while not animator.draw_exposure(iexp[0], nightly=True):
iexp[0] += 1
else:
animator.draw_exposure(iexp=iframe, nightly=False)
return animator.artists
log.info('Movie will be {:.1f} mins long at {:.1f} frames/sec.'.format(
nframes / (60 * args.fps), args.fps))
animation = matplotlib.animation.FuncAnimation(animator.figure,
update,
init_func=init,
blit=True,
frames=nframes)
writer = matplotlib.animation.writers['ffmpeg'](
bitrate=2400, fps=args.fps, metadata=dict(artist='surveymovie'))
save_name = args.save + '.mp4'
animation.save(save_name, writer=writer, dpi=animator.dpi)
log.info('Saved {0}.'.format(save_name))
dt = d[idx]["t"] - d[idx - 1]["t"]
t = (t - d[idx - 1]["t"]) / dt
pos = (posNext - posLast) * t + posLast
return pos
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("map", help="input file containing map")
parser.add_argument("schedule", help="schedule for agents")
parser.add_argument(
'--video',
dest='video',
default=None,
help="output video file (or leave empty to show on screen)")
parser.add_argument("--speed", type=int, default=1, help="speedup-factor")
args = parser.parse_args()
with open(args.map) as map_file:
map = yaml.load(map_file)
with open(args.schedule) as states_file:
schedule = yaml.load(states_file)
animation = Animation(map, schedule)
if args.video:
animation.save(args.video, args.speed)
else:
animation.show()
def save_animated_graph(animation, writer, name):
print("\nCurrently saving:", name)
animation.save(name, writer=writer)
if s1 < s2:
b1.health -= diff
b2.strength += boost
if b1.health < 0:
bots.remove(b1)
bots.append(new_bot())
if b2.health < 0:
bots.remove(b2)
bots.append(new_bot())
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation
number_of_frames = 200
def update_hist(num):
for x in range(100):
step_bots()
plt.cla()
plt.hist(np.array([b.aggro for b in bots]), range=(0, 1))
fig = plt.figure()
hist = plt.hist(np.array([b.aggro for b in bots]))
animation = animation.FuncAnimation(fig, update_hist, number_of_frames )
animation.save("state_of_nature.mp4")
dose_imm.set_data(dataDoseMatrix)
dose_imm.autoscale()
# dose via bw
#dataBixelweights = np.genfromtxt(pathOutputDir + relevantFilesBW[i], delimiter=',')
#dose_bw = np.dot(np.matrix.transpose(dataDij),np.matrix.transpose(dataBixelweights))
#dose_bw = np.reshape(dose_bw, np.shape(dataCT)[::-1])
#dose_bw = np.transpose(dose_bw)
#dose_imb.set_array(dose_bw)
#dose_imb.autoscale()
Writer = anim.writers['ffmpeg']
writer = Writer(fps=15, metadata=dict(artist='Me'), bitrate=1800)
anim = anim.FuncAnimation(fig,
animate,
frames=len(relevantFilesDose),
interval=50,
repeat=False)
anim.save('tmp.mp4', writer=writer)
#dataMinDoseMatrix = np.transpose(np.reshape(dataMinDoseMatrix, np.shape(dataCT)[::-1]))
#dataVOIMatrix = np.transpose(np.reshape(dataVOIMatrix, np.shape(dataCT)[::-1]))
#plt.imshow(dataMinDoseMatrix, cmap='jet', interpolation='none', alpha=0.6)
#plt.imshow(dataVOIMatrix, cmap='jet', interpolation='none', alpha=0.4)
#plt.contourf(maskedDose, cmap='jet', interpolation='none', alpha=0.4)
plt.show()
def main(args):
"""Command-line driver to visualize survey scheduling and progress.
"""
# Set up the logger
if args.debug:
log = desiutil.log.get_logger(desiutil.log.DEBUG)
args.verbose = True
elif args.verbose:
log = desiutil.log.get_logger(desiutil.log.INFO)
else:
log = desiutil.log.get_logger(desiutil.log.WARNING)
# Freeze IERS table for consistent results.
desisurvey.utils.freeze_iers()
# Set the output path if requested.
config = desisurvey.config.Configuration()
if args.output_path is not None:
config.set_output_path(args.output_path)
if args.tiles_file is not None:
config.tiles_file.set_value(args.tiles_file)
# Look for the exposures file in the output path by default.
args.exposures = config.get_path(args.exposures)
# Initialize.
animator = Animator(
args.exposures, args.start, args.stop, args.label, args.scores)
log.info('Found {0} exposures from {1} to {2} ({3} nights).'
.format(animator.num_exp, args.start, args.stop,
animator.num_nights))
animator.init_figure(args.nightly)
if args.expid is not None:
expid = animator.exposures['EXPID']
assert np.all(expid == expid[0] + np.arange(len(expid)))
if (args.expid < expid[0]) or (args.expid > expid[-1]):
raise RuntimeError('Requested exposure ID {0} not available.'
.format(args.expid))
animator.draw_exposure(args.expid - expid[0], args.nightly)
save_name = args.save + '.png'
plt.savefig(save_name)
log.info('Saved {0}.'.format(save_name))
else:
nframes = animator.num_nights if args.nightly else animator.num_exp
iexp = [0]
def init():
return animator.artists
def update(iframe):
if (iframe + 1) % args.log_interval == 0:
log.info('Drawing frame {0}/{1}.'
.format(iframe + 1, nframes))
if args.nightly:
while not animator.draw_exposure(iexp[0], nightly=True):
iexp[0] += 1
else:
animator.draw_exposure(iexp=iframe, nightly=False)
return animator.artists
log.info('Movie will be {:.1f} mins long at {:.1f} frames/sec.'
.format(nframes / (60 * args.fps), args.fps))
animation = matplotlib.animation.FuncAnimation(
animator.figure, update, init_func=init, blit=True, frames=nframes)
writer = matplotlib.animation.writers['ffmpeg'](
bitrate=2400, fps=args.fps, metadata=dict(artist='surveymovie'))
save_name = args.save + '.mp4'
animation.save(save_name, writer=writer, dpi=animator.dpi)
log.info('Saved {0}.'.format(save_name))
circle = drawLoop(p1, 2, 1, animRes) # 2e^(2*pi*i*t)
Rd = drawLoop(p1, 2, 4, animRes) # 2^d*e^(8*pi*i*t)
lSpace = straightLineHomotopy(pZ, Rd)
# lSpace = straightLineHomotopy(circle,Rd)
#print(lSpace)
#######################
# Visualizing results #
#######################
fig, ax = plt.subplots()
d1, = plt.plot([x.real for x in lSpace[0]], [x.imag for x in lSpace[0]],
color='blue')
d2, = plt.plot([x.real for x in lSpace[animRes - 1]],
[x.imag for x in lSpace[animRes - 1]],
color='red')
# Animate
def animateH(i):
d1.set_data([x.real for x in lSpace[i]], [x.imag for x in lSpace[i]])
anim = anim.FuncAnimation(fig, animateH, frames=list(range(0,animRes)), \
interval=100, blit=False, repeat=True)
ax.set(xlabel='Re(z)', ylabel='Im(z)')
ax.set(title='Map from p(z) to a circle with d=3')
plt.draw()
anim.save('slh_6.mp4', fps=60, extra_args=['-vcodec', 'libx264'])
def animate3d(i):
x = statet[:, 0]
y = statet[:, 1]
z = statet[:, 2]
line3d.set_data(x[:i], y[:i], z[:i])
return line3d,
ani = ani.FuncAnimation(fig,
animate,
len(statet[:, 0]),
interval=5,
blit=False)
#ani3d = ani.FuncAnimation(fig, animate3d, len(statet[:,0]), interval = 5, blit=False)
#plt.plot(statet[:,0],statet[:,1])
ani.save('2dlorrenz.gif', writer='ffmpeg')
plt.show()
"""
ax = fig.gca(projection="3d")
ax.plot(statet[:, 0], statet[:, 1], statet[:, 2])
plt.draw()
plt.show()
#for updating frames
def update(i,factor):
line.set_xdata(state[:,0])
line.set_ydata(state[:,1])
line.set_zdata(state[:,2])
return line
"""
from matplotlib import pyplot as plt
from matplotlib import animation
fig, ax = plt.subplots()
x = np.arange(0, 2 * np.pi, 0.01)
line0 = ax.plot(x, np.cos(x))
line, = ax.plot(x, np.sin(x))
def init():
line.set_ydata(np.sin(x))
return line,
def animate(i):
line.set_ydata(np.sin(x + i / 10.0))
return line,
animation = animation.FuncAnimation(fig=fig,
func=animate,
frames=100,
init_func=init,
interval=20,
blit=False)
animation.save('resetvalue.gif', writer='imagemagick')
plt.show()
plt.xlim(-world['x'] * 0.55, world['x'] * 0.55)
plt.ylim(-world['y'] * 0.55, world['y'] * 0.55)
plt.savefig('exports/test.png')
def update(frame_number):
preysScatGraph.set_offsets(np.c_[preysData[frame_number]["x"],
preysData[frame_number]["y"]])
predatorsScatGraph.set_offsets(np.c_[predatorsData[frame_number]["x"],
predatorsData[frame_number]["y"]])
foodScatGraph.set_offsets(np.c_[foodData[frame_number]["x"],
foodData[frame_number]["y"]])
animation = animation.FuncAnimation(fig,
update,
interval=40,
frames=totalFrames)
# plt.show()
animation.save('exports/im.mp4', writer=writer)
title = 'worldSim'
message = 'Video is ready'
# notification.notify(title=title,
# message=message,
# app_icon=None,
# timeout=10,
# toast=False)
1.75,
"t={:2.3f}".format(t_eval[0]),
fontsize=10,
ha="center")
ax.text(0,
1.85,
"Solved by Pesudospectral with RK44".format(t_eval[0]),
fontsize=10,
ha="center")
def init():
ax.set_xlim(*x_span)
ax.set_ylim(-0.05, 2.)
return ln,
def animate(i):
ln.set_data(x_eval, w[i, :])
tx.set_text("t={:2.3f}".format(t_eval[i]))
return ln,
animation = animation.FuncAnimation(fig=fig,
func=animate,
frames=300,
init_func=init,
interval=20,
blit=False)
animation.save('redraw.gif', writer='imagemagick')
# and outputs a long matrix that shows the continuous deformation
# of one loop into the other.
p = polynomial(lambda z: z**4 + z**2 - z + 2, r'$p(z) = z^4 + z^2 - z + 2$')
pZ = drawLoop(p, 2, 1, animRes)
# lSpace = straightLineHomotopy(circle,Rd)
#print(lSpace)
#######################
# Visualizing results #
#######################
fig, ax = plt.subplots()
plt.plot([x.real for x in pZ], [x.imag for x in pZ], color='blue')
d1, = plt.plot([pZ[0].real, 0], [pZ[0].imag, 0], marker='o', color='red')
# Animate
def animateH(i):
d1.set_data([pZ[i].real, 0], [pZ[i].imag, 0])
anim = anim.FuncAnimation(fig, animateH, frames=list(range(0,animRes)), \
interval=100, blit=False, repeat=True)
ax.set(xlabel='Re(z)', ylabel='Im(z)')
ax.set(title='w(p(z),0)')
plt.draw()
anim.save('wind1.mp4', fps=60, extra_args=['-vcodec', 'libx264'])
if index == 1:
joint.goal_position = -angles[index] / np.pi * 180 - 90
else:
joint.goal_position = -angles[index] / np.pi * 180
else:
joint.goal_position = angles[index] / np.pi * 180
third_arm.r_m5.goal_position = 0
if (animate):
# Définition de la trajectoire
arm_length = fk.get_robot_length(third_arm_parameters)
t = np.arange(0, np.pi / 2, np.pi / 50)
x = np.sin(t**2) * arm_length / 3
y = np.sin(t) * arm_length / 3
z = -np.sinh(t) * arm_length / 3
x2 = np.sqrt(x)
y2 = y**2
z2 = z
fig = matplotlib.pyplot.figure()
# Génération de l'animation
animation = plot_utils.animate_IK(third_arm_parameters, third_arm_starting_angles, x, y, z, fig, third_arm_bounds)
# Sauvegarde de l'animation
animation.save('output/test.mp4', writer=plot_utils.animation_writer)
matplotlib.pyplot.show()
return self.img, self.laser_filed_plot
fig = plt.gcf()
visualizer = VisualizeDynamicsPhaseSpace(fig, sys_params)
animation = matplotlib.animation.FuncAnimation(
fig, visualizer, frames=np.arange(100), init_func=visualizer.empty_frame, repeat=True, blit=True
)
plt.show()
# Set up formatting for the movie files
writer = matplotlib.animation.writers['mencoder'](fps=5, metadata=dict(artist='Denys Bondar'))
# Save animation into the file
animation.save('strong_field_physics.mp4', writer=writer)
# extract the reference to quantum system
quant_sys = visualizer.quant_sys
#################################################################
#
# Plot the Ehrenfest theorems after the animation is over
#
#################################################################
# generate time step grid
dt = quant_sys.dt
times = dt * np.arange(len(quant_sys.X_average)) + dt
plt.subplot(131)
ax.add_geometries(counties.geometries(), cartopy.crs.PlateCarree(),
facecolor='#C2A385', edgecolor='grey', zorder=1)
# Interstates
interstate = cartopy.io.shapereader.Reader('data/interstates')
ax.add_geometries(interstate.geometries(), cartopy.crs.PlateCarree(),
facecolor='none', edgecolor='#B20000', zorder=1)
# Hydrography
#hydro = cartopy.io.shapereader.Reader('data/hydro')
#ax.add_geometries(hydro.geometries(), cartopy.crs.PlateCarree(),
# facecolor='none', edgecolor='#ADD6FF', zorder=1)
# Set limits in lat/lon space
# LonW, LonE, LatN, LatS
#ax.set_extent([-81.8, -80, 36, 34.5])
print("Building Figure...")
norm, cmap = ctables.registry.get_with_steps(colorTable, 5, 5)
plot = ax.pcolormesh(x, y, ref, cmap=cmap, norm=norm, zorder=2)
#ax.contourf(x, y, ref, cmap=cmap, norm=norm, zorder=2)
title_line1 = '%s %s - %i:%i' % (args.site,args.product,hour,minute)
plt.title(title_line1,color='k',fontsize=18,fontweight='bold',style='italic')
if args.animate == 'true':
animation = animation.FuncAnimation(fig, update, interval=15, blit=False, frames=10)
animation.save('nexpy.gif', writer='imagemagick', fps=15, dpi=40)
plt.show()
def save_animation(animation, filename):
animation.save(filename)
x2=numpy.zeros(num)
x3=numpy.zeros(num)
x4=numpy.zeros(num)
vstack_tmp1=[]
vstack_tmp2=[]
vstack_tmp3=[]
vstack_tmp4=[]
for i in xrange(1,n+1):
x1+=numpy.random.randn(num)
x2+=numpy.random.gamma(1,1,num)
x3+=numpy.random.uniform(0,1,num)
x4+=numpy.random.beta(0.5,0.5,num)
vstack_tmp1.append(x1/i)
vstack_tmp2.append(x2/i)
vstack_tmp3.append(x3/i)
vstack_tmp4.append(x4/i)
data1=numpy.vstack(vstack_tmp1)
data2=numpy.vstack(vstack_tmp2)
data3=numpy.vstack(vstack_tmp3)
data4=numpy.vstack(vstack_tmp4)
fig = pyplot.figure(figsize=(9,8))
animation = animation.FuncAnimation(fig, update_hist, fargs=(data1, data2, data3, data4, num), frames=100, interval=100)
animation.save('day7_CentralLimit.mp4', fps=3)
clip = VideoFileClip("day7_CentralLimit.mp4")
clip.write_gif("day7_CentralLimit.gif")
#pyplot.show()
