def sim_animation(evaluation, show=True, save=False, fname=None):
# nrows, ncols, index
fig = plt.figure(figsize=[12, 12])
# best
ax1 = fig.add_subplot(2, 2, 1)
# remaining alphas
ax2 = fig.add_subplot(4, 4, 3)
ax3 = fig.add_subplot(4, 4, 4)
ax4 = fig.add_subplot(4, 4, 7)
ax5 = fig.add_subplot(4, 4, 8)
# ft parameter values
ax6 = fig.add_subplot(4, 2, 5)
# genotype
ax7 = fig.add_subplot(2, 4, 7)
# network
ax8 = fig.add_subplot(2, 4, 8)
# ax9 ??
ax9 = fig.add_subplot(4, 2, 7)
# best trial, and the remaining alphas
genotype = evaluation.genotype
best_trial = evaluation.trials[0]
best_trial_time = len(best_trial.data_ft)
# sorted remaining (different alphas)
alphas = [best_trial.alpha]
rm_trials = []
for trial in evaluation.trials[1:]:
if trial.alpha not in alphas:
alphas.append(trial.alpha)
rm_trials.append(trial)
# text above
fig.suptitle("{}".format(fname), ha="center", va="center")
time = fig.text(0.5,
0.92,
"time=0".format(best_trial.ft),
ha="center",
va="center")
# ax1: basics, objects for agents and ir sensors
ax1.set_title("alpha={}, ft={}".format(
np.round(np.degrees(best_trial.alpha), 2), np.round(best_trial.ft), 2))
ax1.set_xlim(-100, 100)
ax1.set_ylim(-100, 100)
ax1.set_aspect("equal")
agents = []
ag_colors = ["blue", "green", "red"]
trajs = []
irs = []
for i in range(len(best_trial.agents)):
ag, = ax1.plot([], [], color="black")
agents.append(ag)
ag_irs = []
traj, = ax1.plot([], [], color=ag_colors[i])
trajs.append(traj)
for irx in best_trial.agents[i].sensors.irx:
if irx:
ir, = ax1.plot([], [], color="black")
ag_irs.append(ir)
irs.append(ag_irs)
ags, = ax1.plot([], [], color="grey", linestyle="dashed")
centroid, = ax1.plot([], [], marker="x", color="grey")
# ax2-5: centroids, space and text
ax2.set_title("alpha={}, ft={}".format(
np.round(np.degrees(evaluation.trials[1].alpha)),
np.round(evaluation.trials[1].ft), 2))
ax2.set_xlim(-60, 60)
ax2.set_ylim(-60, 60)
cent2, = ax2.plot([], [], marker="x", color="black")
ax2.tick_params(axis="y",
which="both",
left=False,
right=True,
labelleft=False)
ax3.set_title("alpha={}, ft={}".format(
np.round(np.degrees(evaluation.trials[2].alpha)),
np.round(evaluation.trials[2].ft), 2))
ax3.set_xlim(-60, 60)
ax3.set_ylim(-60, 60)
cent3, = ax3.plot([], [], marker="x", color="black")
ax4.set_title("alpha={}, ft={}".format(
np.round(np.degrees(evaluation.trials[3].alpha)),
np.round(evaluation.trials[3].ft), 2),
y=-0.18)
ax4.set_xlim(-60, 60)
ax4.set_ylim(-60, 60)
ax4.tick_params(axis="x",
which="both",
bottom=False,
top=True,
labelbottom=False)
ax4.tick_params(axis="y",
which="both",
left=False,
right=True,
labelleft=False)
cent4, = ax4.plot([], [], marker="x", color="black")
ax5.set_title("alpha={}, ft={}".format(
np.round(np.degrees(evaluation.trials[4].alpha)),
np.round(evaluation.trials[4].ft), 2),
y=-0.18)
ax5.set_xlim(-60, 60)
ax5.set_ylim(-60, 60)
ax5.tick_params(axis="x",
which="both",
bottom=False,
top=True,
labelbottom=False)
cent5, = ax5.plot([], [], marker="x", color="black")
# ax7: network neural space
ax7.set_xlim(0, 200)
ax7.set_ylim(0, 250)
ax7.tick_params(axis="y",
which="both",
left=False,
right=True,
labelleft=False)
# ax8: network
ax8.set_xlim(0, 200)
ax8.set_ylim(0, 250)
# ax6: plot dist,maxdist, gt, cp, ft
ax6.set_xlim(0, best_trial_time)
ax6.set_ylim(0, 1.01)
tbar, = ax6.plot([], [], color="black")
# ax9: plot d0,d1,d2, st,stft, gt
ax9.set_xlim(0, best_trial_time)
ax6.set_ylim(0, 1.01)
tbar, = ax6.plot([], [], color="black")
# to pause the animation and check data
anim_running = True
def onClick(event):
nonlocal anim_running
if anim_running:
anim.event_source.stop()
anim_running = False
else:
anim.event_source.start()
anim_running = True
xt = best_trial
print("\nxt = trial object\n")
import pdb
pdb.set_trace()
def init():
# remaining alphas trajectories (ax2-ax5)
for enum, xag in enumerate(rm_trials[0].agents):
ax2.plot(xag.data.x, xag.data.y, color=ag_colors[enum])
for enum, xag in enumerate(rm_trials[1].agents):
ax3.plot(xag.data.x, xag.data.y, color=ag_colors[enum])
for enum, xag in enumerate(rm_trials[2].agents):
ax4.plot(xag.data.x, xag.data.y, color=ag_colors[enum])
for enum, xag in enumerate(rm_trials[3].agents):
ax5.plot(xag.data.x, xag.data.y, color=ag_colors[enum])
# ax6
# ycp = [cp[1] for cp in best_trial.data_cp]
cpx = [cp[0] for cp in best_trial.data_cp] + [best_trial_time]
cpy = [cp[1]
for cp in best_trial.data_cp] + [best_trial.data_cp[-1][1]]
ax6.plot(cpx, cpy, label="cp")
# gt, st, ft
ygt = [gt[2] for gt in best_trial.data_gt]
ystft = [st[4] / 3 for st in best_trial.data_st]
yft = [ft[1] / 120 for ft in best_trial.data_ft]
ax6.plot(ygt, label="gt")
ax6.plot(ystft, label="stft/3")
ax6.plot(yft, label="ft/max(ft)")
ax6.legend()
# ax9
#
# ax7: sensor and motor regions
ax7.plot([0, 200], [50, 50], color="black")
ax7.plot([0, 200], [220, 220], color="black")
for sx in evaluation.nx_space.sregion:
ax7.plot(*sx.area.exterior.xy, color="black")
for mx in evaluation.nx_space.mregion:
ax7.plot(*mx.area.exterior.xy, color="black")
# from genotype
for nx in evaluation.network:
# neural region
npoint = plt.Circle((nx.x, nx.y),
radius=1,
fill=True,
color="black")
ax7.add_patch(npoint)
ax7.plot(*nx.area.exterior.xy, color="black")
# input connections
for ci in nx.l_in:
lst = "dashed" if ci[2] < 0 else "solid"
ax7.plot([ci[0], nx.x], [ci[1], nx.y],
color="blue",
linestyle=lst)
# output connections
for co in nx.l_out:
lst = "dashed" if co[2] < 0 else "solid"
ax7.plot([nx.x, co[0]], [nx.y, co[1]],
color="red",
linestyle=lst)
# ax8: actual network
ax8.plot([0, 200], [50, 50], color="black")
ax8.plot([0, 200], [220, 220], color="black")
for sx in evaluation.nx_space.sregion:
ax8.plot(*sx.area.exterior.xy, color="black")
for mx in evaluation.nx_space.mregion:
ax8.plot(*mx.area.exterior.xy, color="black")
# from genotype (only working connections)
for nx in evaluation.network:
# neurons
npoint = plt.Circle((nx.x, nx.y),
radius=1,
fill=True,
color="black")
ax8.add_patch(npoint)
ax8.plot(*nx.area.exterior.xy, color="black")
# input connections
for i in range(len(nx.cx_in)):
if nx.cx_in[i]:
ci = nx.l_in[i]
lst = "dashed" if ci[2] < 0 else "solid"
ax8.plot([ci[0], nx.x], [ci[1], nx.y],
color="blue",
linestyle=lst)
# output connections
for o in range(len(nx.cx_out)):
if nx.cx_out[o]:
co = nx.l_out[o]
lst = "dashed" if co[2] < 0 else "solid"
ax8.plot([nx.x, co[0]], [nx.y, co[1]],
color="red",
linestyle=lst)
return True
def animate(i):
# i: from number of savings in trial
time.set_text("time={}".format(i))
# at: adjusted i for savings from agents' states
at = int(i / evaluation.dt)
# main centroid and triangle
centroid.set_data(best_trial.triangles[i].centroid.xy)
ags.set_data(*best_trial.triangles[i].exterior.xy)
# remaining centroids (can be shorter)
if i < len(rm_trials[0].triangles):
cent2.set_data(rm_trials[0].triangles[i].centroid.xy)
if i < len(rm_trials[1].triangles):
cent3.set_data(rm_trials[1].triangles[i].centroid.xy)
if i < len(rm_trials[2].triangles):
cent4.set_data(rm_trials[2].triangles[i].centroid.xy)
if i < len(rm_trials[3].triangles):
cent5.set_data(rm_trials[3].triangles[i].centroid.xy)
# ax1 agents
for enum, ag in enumerate(best_trial.agents):
# agent body
agents[enum].set_data(*ag.data.body[at].exterior.xy)
# trajectories
trajs[enum].set_data(ag.data.x[:at], ag.data.y[:at])
# sensors
ag_irs = [ir for ir in ag.data.irs[at] if ir]
for n_ir, ir in enumerate(ag_irs):
irs[enum][n_ir].set_data(*ir.xy)
all_irs = [ir for irx in irs for ir in irx]
# time mark for ax6
tbar.set_data([i, i], [0, 1])
#import pdb; pdb.set_trace()
return centroid, ags, traj, tuple(agents) + tuple(all_irs)
fig.canvas.mpl_connect('button_press_event', onClick)
anim = animation.FuncAnimation(fig,
animate,
init_func=init,
frames=best_trial_time,
interval=10,
blit=False,
repeat=False)
if save:
# writer for saving the animation
xwriter = animation.FFMpegWriter(fps=30)
try:
anim.save("{}.mp4".format(fname), writer=xwriter)
except:
print('\ncouldn\'t save animation...')
if show:
plt.show()
plt.close("all")
ax1.clear()
k=k+1
for j in range (30):
A=(1.0-(4*d_t*alpha/hs))*tf_a[1:-1,1:-1]
B=(d_t*alpha/hs)*(tf_a[1:-1,:-2]+tf_a[:-2,1:-1]+tf_a[2:,1:-1]+tf_a[1:-1,2:])
tf_a[1:-1,1:-1]=A+B
ax1.imshow(tf_a)
plt.subplots_adjust(top=0.99, right=0.99, left=0.05, bottom=0.01)
# ax.margins(x=0)
print k
plt.rcParams['animation.ffmpeg_path'] ='C:\\ffmpeg\\bin\\ffmpeg.exe'
FFwriter = animation.FFMpegWriter(bitrate=5000,fps=10)
ani = animation.FuncAnimation(fig, animate, frames=200)
ani.save('boxa/result_'+str(hh)+'.mp4', writer=FFwriter)
tf_aa=np.zeros([2,300,300])
#tf_aa=np.append(tf_a,alphaa,axis=1)
tf_aa[0]=tf_a
tf_aa[1]=alphaa
np.save('boxa/data/data_'+str(hh)+'.npy',tf_aa)
##
##
#
import numpy as np
from build_data import build_city_data, build_plot_data
from plot_data import plot_chart
cities = build_city_data()
names, pop_fns, lats, longs, colors = build_plot_data(cities)
start_year = 1901
end_year = 2012
speed_multiplier = 3
num_top_cities = 50
interval = (0.06 - 0.001 * num_top_cities) * speed_multiplier
file_name = 'output/animated_only_map_no_labels_' + str(num_top_cities) + '_' + str(start_year) + '_' + str(end_year) + '.mp4'
pop_limit = 100000
# Plots
fig = plt.figure(figsize=(10.8,10.8), tight_layout=True)
writer = animation.FFMpegWriter(fps=60, bitrate=5000)
with writer.saving(fig, file_name, dpi=100):
for t in np.arange(start_year, end_year, interval):
print (str(t))
plot_chart(fig, t, num_top_cities, pop_limit, names, pop_fns, lats, longs, colors,
compress_pops=False, save_img=False, in_animation=True, show_map = True, show_map_labels = False, show_chart = False)
writer.grab_frame()
def create_anim(cut_polyline=None,
pvt=None,
save_path=None,
save_name=None,
save_type='mp4',
skip_frames=20):
"""Save type as 'gif' or 'mp4' """
# for testing
if cut_polyline is None:
cut_polyline = test_poly()
p = np.array(cut_polyline[0])
import generate_pvt
import imp
imp.reload(generate_pvt)
pvt = generate_pvt.GeneratePVT(cut_polyline, smooth_iters=500)
else:
p = np.array(cut_polyline[0])
pvt.p = p
cp_p_line, cp_vel_line = manage_pvt(pvt)
cp_p_line = offset_p_line(cp_p_line)[0]
cp_vel_line = offset_p_line(cp_vel_line)[0]
vel_interp(pvt)
p = pvt.p
p, bc, bcf, tc, tcf, fudge = offset_p_line(p)
interpolate = False
if interpolate:
new_ar = spread_array(p, 5)
else:
new_ar = p
fig, ax = plt.subplots() # Create a figure containing a single axes.
fig.set_size_inches(8, 8, forward=True)
fig.set_dpi(100)
ax.set_xlim((bc, tc))
ax.set_ylim((bc, tc))
# lines ---------------------------------
line, = ax.plot([], [], lw=4.1, label='cut_polyline',
color='deeppink') # cut_polyline
p_line, = ax.plot([], [], lw=2.1, label='P polyline',
color='yellow') # cut_polyline
vel_line, = ax.plot([], [], lw=.5, label='vel * time',
color='black') # cut_polyline
xs_line, = ax.plot([], [], lw=5.0, label='x velocity',
color='red') # x speed
ys_line, = ax.plot([], [], lw=5.0, label='y velocity',
color='greenyellow') # x speed
hs_line, = ax.plot([], [], lw=5.0, label='head speed',
color='dodgerblue') # x speed
xj_line, = ax.plot([], [], lw=5.0, label='x jerk',
color='crimson') # x speed
yj_line, = ax.plot([], [], lw=5.0, label='y jerk', color='gold') # x speed
time_line, = ax.plot([], [], lw=5.0, label='time * 20',
color='purple') # x speed
# points --------------------------------
cp_point, = ax.plot([0], [0], 'go', color='deeppink') # cut_polyline
p_point, = ax.plot([0], [0], 'go', color='yellow') # cut_polyline
v_point, = ax.plot([0], [0], 'go', color='black') # cut_polyline
x_point, = ax.plot([0], [0], 'go', color='red')
y_point, = ax.plot([0], [0], 'go', color='greenyellow')
# ---------------------------------------
ax.legend(loc=2) # Add a legend.
idexer = np.arange(
p.shape[0])[::skip_frames] # skip frames to save animation time
def animate(i):
i = idexer[i]
# poly lines
line.set_data(new_ar[:, 0], new_ar[:, 1])
p_line.set_data(cp_p_line[:, 0], cp_p_line[:, 1])
vel_line.set_data(cp_vel_line[:, 0], cp_vel_line[:, 1])
# bar graphs
q = np.array([[bcf, 0.0], [bcf, 1.2]])
r = np.array([[bcf * 2, 0.0], [bcf * 2, 1.2]])
s = np.array([[bcf * 4, 0.0], [bcf * 4, 1.2]])
t = np.array([[bcf * 6, 0.0], [bcf * 6, 1.2]])
u = np.array([[bcf * 7, 0.0], [bcf * 7, 1.2]])
v = np.array([[bcf * 9, 0.0], [bcf * 9, 1.2]])
q[1][-1] = pvt.xV[i]
r[1][-1] = pvt.yV[i]
s[1][-1] = pvt.hs[i]
t[1][-1] = pvt.xJ[i]
u[1][-1] = pvt.yJ[i]
v[1][-1] = pvt.ti[i] * 10
xs_line.set_data(q[:, 0], q[:, 1])
ys_line.set_data(r[:, 0], r[:, 1])
hs_line.set_data(s[:, 0], s[:, 1])
xj_line.set_data(t[:, 0], t[:, 1])
yj_line.set_data(u[:, 0], u[:, 1])
time_line.set_data(v[:, 0], v[:, 1])
# points
cp_point.set_data(new_ar[:, 0][i], new_ar[:, 1][i])
#p_point.set_data(cp_p_line[:,0][i], cp_p_line[:,1][i])
#v_point.set_data(cp_vel_line[:,0][i], cp_vel_line[:,1][i])
x_point.set_data(new_ar[:, 0][i], [bc + fudge * 0.1])
y_point.set_data([tc - fudge * 0.1], new_ar[:, 1][i])
return (
line,
p_line,
vel_line,
xs_line,
ys_line,
hs_line,
xj_line,
yj_line,
time_line,
cp_point,
p_point,
v_point,
x_point,
y_point,
)
anim = animation.FuncAnimation(fig,
animate,
frames=idexer.shape[0],
interval=20,
blit=True)
path = save_path
name = save_name
if path is None:
path = os.path.expanduser('~/Desktop/')
if save_name is None:
name = 'PVT_movie'
if save_type == 'gif':
anim.save(path + name + '.gif', writer='imagemagick', fps=60)
if save_type == 'mp4':
anim.save(path + name + '.mp4', writer=animation.FFMpegWriter(fps=60))
#plt.show()
plt.close(fig=None)
def AnimateResult(self,
name,
sizex,
sizey,
npx,
npy,
tp_per_real_sec,
max_framerate,
flabelstart,
zmax=1.,
zmin=0.,
filt=False):
fig = plt.figure(figsize=(sizex, sizey))
ax1 = fig.add_subplot(111,
autoscale_on=False,
xlim=(0, self.DomLenX),
ylim=(0, self.DomLenY),
aspect='equal')
#ax2 = fig.add_subplot(132,autoscale_on=False,xlim=(0,self.DomLenX), ylim=(0,self.DomLenY),aspect='equal')
#ax3 = fig.add_subplot(133,autoscale_on=False,xlim=(0,self.DomLenX), ylim=(0,self.DomLenY),aspect='equal')
#ax4 = fig.add_subplot(224,autoscale_on=False,xlim=(0,self.DomLen), ylim=(np.amin(self.E),np.amax(self.E)))
x = np.linspace(0., self.DomLenX, npx, endpoint=False)
y = np.linspace(0., self.DomLenY, npy, endpoint=False)
Y, X = np.meshgrid(x, y)
if zmax > 2. * np.amax(self.rho[0].RegularGrid(npx, npy)):
zmax = np.amax(self.rho[0].RegularGrid(npx, npy))
quad1 = ax1.pcolormesh(
X,
Y,
self.rho[0].RegularGrid(npx, npy),
vmax=zmax,
vmin=zmin,
cmap='jet'
) #; quad2 = ax2.pcolormesh(X,Y,self.energy[0].RegularGrid())
#quad3 = ax3.pcolormesh(X,Y,self.phi[0].RegularGrid());
ax1.set_title('Density',
fontsize=14) #; ax2.set_title('KE density',fontsize=14)
#ax3.set_title('Electric Potential',fontsize=14)
#ax3.set_xlabel(r'$x/\lambda_D$',fontsize=13); ax4.set_xlabel(r'$x/\lambda_D$',fontsize=13)
ax1.set_xlabel(r'$x/\lambda_D$', fontsize=13)
ax1.set_ylabel(r'$y/\lambda_D$', fontsize=13)
mult = int(1)
speed = int(tp_per_real_sec * self.rho.shape[0] / self.T)
while speed > max_framerate:
speed = int(speed / 2.)
mult *= 2
numframes = int(self.rho.shape[0] / mult)
print('Number of frames in movie: ' + str(numframes))
print('Framerate = ' + str(speed))
def init():
quad1.set_array(np.ndarray([])) #; quad2.set_array(np.ndarray([]))
#quad3.set_data(np.ndarray([]))
return quad1, #quad2, quad3
def animate(i):
r = self.rho[mult * i].RegularGridBicubic(
npx, npy) #; e = self.energy[i].RegularGrid()
if filt:
r = FIL.BinomialFilter2D(r)
#p = self.phi[i].RegularGrid()
quad1.set_array(
r[:-1, :-1].ravel()) #; quad2.set_array(e[:-1,:-1].ravel())
#quad3.set_array(p[:-1,:-1].ravel())
l = i + flabelstart
fr = 'frame%03d.png' % l
framename = 'MovieFrames/' + name + fr
fig.savefig(framename)
return quad1, #quad2, quad3
fullname = name + '.mp4'
anim = animation.FuncAnimation(fig,
animate,
init_func=init,
frames=numframes,
blit=False)
anim.save(fullname, writer=animation.FFMpegWriter(fps=speed))
def animate_spike_raster(fname_spikes,
fname_movie_out,
nrn_idx=None,
time_mode="real",
time_stop=None,
time_window=1.0,
fps=30):
"""Generate a movie from the spike raster
Parameters
----------
fname_spikes: string
input spike data text filename
first column is sim time
second column is real time
subsequent columns are each neuron's spikes as would be recorded in the nengo simulator
fname_movie_out: string
if string, filename of output movie
nrn_idx: list-like or none
indices of neurons to use to generate wav file
if None, uses all neurons, one per wav file channel
time_mode: "real" or "sim"
Whether to use the spike's real or simulation time
time_stop: float or None
if float, movie ends time_window after time_stop
if None, movie ends after time_window past last spike
time_window: float
Size of time window over which to view spikes
fps: int
frames per second
"""
sim_time, real_time, spk_data_raw = _load_spike_data(fname_spikes)
if nrn_idx is not None:
spk_data_raw = spk_data_raw[:, nrn_idx]
n_samples, n_neurons = spk_data_raw.shape
if time_mode == "real":
time = real_time
elif time_mode == "sim":
time = sim_time
spk_times = []
for nrn_idx in range(n_neurons):
spk_idx = np.nonzero(spk_data_raw[:, nrn_idx])[0]
spk_times.append(time[spk_idx])
fig = plt.figure()
colors = plt.rcParams['axes.prop_cycle'].by_key()['color']
ax = fig.add_subplot(111)
y_range = 0.8
last_spk_time = 0.
for nrn_idx in range(n_neurons):
y_mid = nrn_idx
y_min = y_mid - y_range / 2.
y_max = y_mid + y_range / 2.
spk_idx = np.nonzero(spk_data_raw[:, nrn_idx])[0]
spk_times = time[spk_idx]
last_spk_time = np.max(spk_times.tolist() + [last_spk_time])
ax.vlines(spk_times, y_min, y_max, colors[nrn_idx % len(colors)])
ax.set_ylim(-y_range / 1.5, n_neurons - 1 + y_range / 1.5)
ax.set_title("Spike Raster")
ax.set_xlabel("Time (s)")
ax.set_ylabel("Neuron Index")
ax.set_yticks(_filter_nrn_idx_yticks(ax.get_yticks(), n_neurons))
time_start = -time_window
if time_stop is None:
time_stop = last_spk_time + time_window
else:
time_stop = time_stop + time_window
animation_time_total = time_stop - time_start - time_window
animation_dt = 1. / fps
n_frames = int(np.round(animation_time_total * fps))
moviewriter = animation.FFMpegWriter(fps=fps)
with moviewriter.saving(fig, fname_movie_out, dpi=100):
for frame_idx in range(n_frames):
time_since_start = frame_idx * animation_dt
ax.set_xlim(time_start + time_since_start,
time_start + time_since_start + time_window)
moviewriter.grab_frame()
import numpy as np
from time import time
import multiprocessing as mp
import matplotlib.pyplot as plt
from athena_read import athdf
import matplotlib.gridspec as gridspec
from matplotlib import animation
from matplotlib import rc
import pandas as pd
from mpl_toolkits.axes_grid1.inset_locator import inset_axes
rc('text', usetex=True)
rc('font', family='serif', size=12)
#creat movie writter
FFwriter = animation.FFMpegWriter(
fps=20, extra_args=['-vcodec', 'libx264', '-pix_fmt', 'yuv420p'])
#reading in pm_trackfile using pandas
pmtrackfile = pd.read_csv("pm_trackfile.dat", delim_whitespace=True)
#reading the hdf5 data dumps
frame = athdf("BDstream.out1.00100.athdf")
#the range in R direction we want to plot, in index
rmin = 0
rmax = 384
#creat np.meshgrid from the coordinate
#['x1f'] is the face-centered R direction coordinates, ['x2f'] is the face-centered Phi direction coordinates.
r, phi = np.meshgrid(frame['x1f'][rmin:rmax], frame['x2f'])
X = r * np.sin(phi)
# Load ground_truth bounding boxes from the file (remove useless data)
gt_boxes = np.loadtxt(gt_boxes_file, delimiter=',')
gt_boxes = gt_boxes[:, :6]
# Collect names of all images of the input video
in_image_names = os.listdir(path=input_path)
in_image_names.sort()
# Defne bounding-box colors
colors = [(255, 0, 0), (0, 255, 0), (0, 0, 255), (255, 0, 255), (128, 0, 0),
(0, 128, 0), (0, 0, 128), (128, 0, 128), (128, 128, 0),
(0, 128, 128)]
# Initialize the writer object (converts frames into the video)
writer = anim.FFMpegWriter(fps=25, codec='mpeg4', bitrate=5000)
plt.figure()
fig, ax = plt.subplots(1, figsize=(12.8, 7.2), dpi=100)
# Open the stream to the output video, which will be built frame by frame
with writer.saving(fig, output_video_path, dpi=100):
frame_number = 0
# Load each frame of the input video
for img_name in tqdm(in_image_names):
frame_number += 1
# Take next frame of the video and get detections
pil_img = Image.open(input_path + img_name)
import networkx as nx
import matplotlib.patches as pt
import matplotlib.pyplot as plt
import random
from matplotlib import animation
import d2dLedgerNode
Animation = False
if (Animation):
mp4writer = animation.FFMpegWriter(fps=3, metadata=dict(artist='kshibata'), bitrate=4000)
width = 1920
height = 1080
timeLength = 20
node_count = 50
maxrange = 300
start_time = 1
ComErrorRatio = 20 # %
dataErrorRatio = 1 # %
waitTime = 8
testRequest = [{'type':'newRequest','payload':[{'type':'pointTransfer','from':'B0000002','to':'C0000003','amount':500}]}]
#
G = nx.DiGraph()
G2 = nx.DiGraph()
G2.add_node(0,Position=(0,0))
for i in range(20):
for j in range(10):
c = complex(-0.6 - j / 100, -0.1 - i / 200)
plt.axis("off")
julia = julia_set(c, mkplot=False)
t = ax.annotate(f"({round(c.real, 2)}, {round(c.imag, 2)})", (225, 10),
color="w")
plot = ax.imshow(julia, interpolation="nearest", cmap="gnuplot2")
ims.append((plot, t))
im_ani = animation.ArtistAnimation(fig,
ims,
interval=500,
repeat_delay=3000,
blit=True)
im_ani.save("c_choice.mp4", writer=animation.FFMpegWriter())
julia_set(complex(-0.418, -0.59), mkplot=True)
julia_set(complex(-0.593, -0.443), mkplot=True)
julia_set(complex(-0.155, -0.653), mkplot=True)
julia_set(complex(-0.715, -0.225), mkplot=True)
julia_set(complex(-0.705, -0.266), mkplot=True)
# Variants of the Julia set
def julia_set_log(c, base, mkplot=False, savefig=False, cmap="gnuplot2"):
"""
Returns a matrix of pixel values, and optionally displays a plot
:param c: the complex seed for the julia set fractal
:param mkplot: whether to create the plot
:param cmap: the matplotlib colourmap as a string
serie_s10 = df.iloc[:, 11].tolist()
serie_s11 = df.iloc[:, 12].tolist()
##### SETTINGS #####
lista_grilla_fuerzas = crea_lista_grilla_fuerzas(timestep_min, timestep_max)
##### SETTINGS #####
total_frames = len(lista_grilla_fuerzas)
grid_x = np.linspace(xi, xf, cols)
grid_y = np.linspace(yi, yf, rows)
grid_density0 = lista_grilla_fuerzas[0]
##### PLOT #####
fig = plt.figure()
ax = plt.axes(xlim=(-1, 1), ylim=(0, 1.2))
grafica_bordes_chaleco()
levels = np.linspace(10, np.max(lista_grilla_fuerzas), 70, endpoint=True)
levbar = np.linspace(10, np.max(lista_grilla_fuerzas), 8, endpoint=True)
cont = plt.contourf(grid_x, grid_y, grid_density0, levels, cmap=plt.cm.jet)
plt.colorbar(ticks=levbar)
plt.grid(False)
plt.xlabel('$x$-location~(m)', fontsize=10)
plt.ylabel('$y$-location~(m)', fontsize=10)
plt.xlim(-0.5, 1.5)
plt.ylim(0, 1.2)
plt.subplots_adjust(bottom=0.29, right=0.98, left=0.15)
##### ANIMATION #####
anim = animation.FuncAnimation(fig, animate, frames=total_frames, repeat=False)
anim.save('{}.mp4'.format(output_filename), writer=animation.FFMpegWriter())
origin='lower',
extent=[0, Lx, 0, Ly],
aspect='equal',
vmin=-0.1,
vmax=0.1)
ims.append([im])
gc.collect()
stop = time.time()
print("DONE!")
print("Min Energy:", np.min(U))
print("Max Energy:", np.max(U))
#
# STEP 4: VISUALIZATION!
#
if animate:
an = anim.ArtistAnimation(fig, ims, interval=1, repeat_delay=0, blit=True)
writer = anim.FFMpegWriter(fps=30)
if save:
an.save('bz_vid.mp4', writer=writer, dpi=500)
#Plot3D(xv, yv, Bz)
Plot2D(xv, yv, Bz)
Energy(U)
DivE(divE)
plt.show()
def central_dot(filename_out, seconds, fps=30, detector=None):
''' Generate a video of a central dot
running for the defined number of
seconds, typically used as resting
interval for visual experiments
Parameters
----------
filename_out: str,
Path and name of the MP4 video file to be created
seconds: int,
Length in seconds of the video file to be created
fps: int, optional
Frames per second of the generated video. (default=30)
detector: float (0-1), None, optional
If a light detector will be used, creates a corner
with brightness provided by the user (0-1).
Otherwise, detector is set to None and no corner
is drawn
Returns
-------
(none) (output video is saved in the specified filename_out)
See Also
--------
preprocess: reads a CSV file from VICON Motion Capture and
creates a new CSV file only with the trajectories,
changing to another reference frame, if convenient
make_video: uses pre-processed VICON data to generate
video of the movement at specified viewing angle
scrambled_video: uses pre-processed VICON data to produce
video of scrambled points (non-biological motion)
gen_detector_intro: creates a detector calibration to be
included at the start of experiments requiring precise
sychronization.
Example
-------
vicon.central_dot('C:\\Users\\MyUser\\Documents\\Vicon\\rest_video.mp4',
15,detector=0.7)
'''
import numpy as np
import pandas as pd
import matplotlib
matplotlib.use('TkAgg') # Needed to run on mac
from matplotlib import pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from matplotlib.colors import cnames
from matplotlib import animation
from matplotlib import patches as patches
numframes = seconds * fps
#generate figure
fig = plt.figure()
plt.style.use('dark_background')
fig.subplots_adjust(left=0,
bottom=0,
right=1,
top=1,
wspace=None,
hspace=None)
fig.set_size_inches(13.66, 7.68, forward=True)
ax = plt.axes()
def animate(i):
#plot the points
ax.clear()
ax.scatter(0.5, 0.5, c='w', alpha=0.7)
#set axis limits, removeing grid, setting background etc
ax.set_xlim(0, 1)
ax.set_ylim(0, 1)
if detector != None:
ax.add_patch(
patches.Rectangle((0.95, 0.85),
0.1,
0.3,
fill=True,
fc=(detector, detector, detector),
zorder=2,
clip_on=False))
ax.patch.set_facecolor('black')
fig.set_facecolor('black')
plt.axis('off')
plt.grid(b=None)
#make animation
ani = animation.FuncAnimation(fig, animate, frames=numframes)
#setting up animation file
Writer = animation.writers['ffmpeg']
writer = animation.FFMpegWriter(fps=fps,
metadata=dict(artist='NeuroMat'),
bitrate=1800,
extra_args=['-vcodec', 'libx264'])
#save animation
ani.save(filename_out, writer=writer)
plt.close()
if booshow:
pass
else:
if boolog:
logn = 'log'
else:
logn = 'lin'
matplotlib.rcParams['animation.ffmpeg_path'] = 'ffmpeg'
moviefile = filename.split('.npy')[0] + 'movie' + logn + str(
int(time.time())) + '.mp4'
if boompg:
# for web compatibility
FFwriter = animation.FFMpegWriter(bitrate=1000,
codec='libx264',
extra_args=[
'-pix_fmt', 'yuv420p', '-preset',
'slow', '-profile:v', 'baseline',
'-level', '3.0'
],
fps=gfps)
else:
# default
FFwriter = animation.FFMpegWriter(bitrate=1000,
fps=gfps,
codec='libx264',
extra_args=[
'-crf', '5', '-preset',
'veryslow', '-pix_fmt', 'yuv420p'
])
#the options are there to enforce compatibility with the Chrome web browser
def WaterSurfaceProfile(self,
Sub,
PlotStart,
PlotEnd,
Interval=200,
XS=0,
XSbefore=10,
XSafter=10,
Save=False,
Path='',
SaveFrames=60):
"""
=============================================================================
WaterSurfaceProfile(Sub, PlotStart, PlotEnd, interval = 200, XS=0,
XSbefore = 10, XSafter = 10)
=============================================================================
Parameters
----------
Sub : [Object]
Sub-object created as a sub class from River object.
PlotStart : [datetime object]
starting date of the simulation.
PlotEnd : [datetime object]
end date of the simulation.
Interval : [integer], optional
speed of the animation. The default is 200.
XS : [integer], optional
order of a specific cross section to plot the data animation around it. The default is 0.
XSbefore : [integer], optional
number of cross sections to be displayed before the chosen cross section . The default is 10.
XSafter : [integer], optional
number of cross sections to be displayed after the chosen cross section . The default is 10.
Save : [Boolen/string]
different formats to save the animation 'gif', 'avi', 'mov', 'mp4'.The default is False
Path : [String]
Path where you want to save the animation, you have to include the
extension at the end of the path.
SaveFrames : [integer]
numper of frames per second
in order to save a video using matplotlib you have to download ffmpeg from
https://ffmpeg.org/ and define this path to matplotlib
import matplotlib as mpl
mpl.rcParams['animation.ffmpeg_path'] = "path where you saved the ffmpeg.exe/ffmpeg.exe"
Returns
-------
TYPE
"""
assert PlotStart < PlotEnd, "start Simulation date should be before the end simulation date "
if Sub.from_beginning == 1:
Period = Sub.Daylist[np.where(
Sub.ReferenceIndex == PlotStart)[0][0]:np.where(
Sub.ReferenceIndex == PlotEnd)[0][0] + 1]
else:
ii = Sub.ReferenceIndex.index[np.where(
Sub.ReferenceIndex == PlotStart)[0][0]]
ii2 = Sub.ReferenceIndex.index[np.where(
Sub.ReferenceIndex == PlotEnd)[0][0]]
Period = list(range(ii, ii2 + 1))
counter = [(i, j) for i in Period for j in hours]
fig = plt.figure(60, figsize=(20, 10))
gs = gridspec.GridSpec(nrows=2, ncols=6, figure=fig)
ax1 = fig.add_subplot(gs[0, 2:6])
ax1.set_ylim(0, int(Sub.Result1D['q'].max()))
if XS == 0:
# plot the whole sub-basin
ax1.set_xlim(Sub.XSname[0] - 1, Sub.XSname[-1] + 1)
ax1.set_xticks(Sub.XSname)
ax1.set_xticklabels(Sub.XSname)
else:
# not the whole sub-basin
FigureFirstXS = Sub.XSname[XS] - XSbefore
FigureLastXS = Sub.XSname[XS] + XSafter
ax1.set_xlim(FigureFirstXS, FigureLastXS)
ax1.set_xticks(list(range(FigureFirstXS, FigureLastXS)))
ax1.set_xticklabels(list(range(FigureFirstXS, FigureLastXS)))
ax1.tick_params(labelsize=6)
ax1.set_xlabel('Cross section No', fontsize=15)
ax1.set_ylabel('Discharge (m3/s)', fontsize=15, labelpad=0.5)
ax1.set_title('Sub-Basin' + ' ' + str(Sub.ID), fontsize=15)
ax1.legend(["Discharge"], fontsize=15)
Qline, = ax1.plot(
[], [], linewidth=5
) #Sub.Result1D['q'][Sub.Result1D['day'] == Sub.Result1D['day'][1]][Sub.Result1D['hour'] == 1]
ax1.grid()
### BC
# Q
ax2 = fig.add_subplot(gs[0, 1])
ax2.set_xlim(1, 25)
ax2.set_ylim(0, int(Sub.QBC.max().max()) + 1)
ax2.set_xlabel('Time', fontsize=15)
ax2.set_ylabel('Q (m3/s)', fontsize=15, labelpad=0.1)
#ax2.yaxis.set_label_coords(-0.05, int(BC_q_T.max().max()))
ax2.set_title("BC - Q", fontsize=20)
ax2.legend(["Q"], fontsize=15)
BC_q_line, = ax2.plot([], [], linewidth=5)
BC_q_point = ax2.scatter([], [], s=300)
ax2.grid()
# h
ax3 = fig.add_subplot(gs[0, 0])
ax3.set_xlim(1, 25)
ax3.set_ylim(float(Sub.HBC.min().min()), float(Sub.HBC.max().max()))
ax3.set_xlabel('Time', fontsize=15)
ax3.set_ylabel('water level', fontsize=15, labelpad=0.5)
ax3.set_title("BC - H", fontsize=20)
ax3.legend(["WL"], fontsize=10)
BC_h_line, = ax3.plot(
[], [], linewidth=5
) #Sub.Result1D['q'][Sub.Result1D['day'] == Sub.Result1D['day'][1]][Sub.Result1D['hour'] == 1]
BC_h_point = ax3.scatter([], [], s=300)
ax3.grid()
# water surface profile
ax4 = fig.add_subplot(gs[1, 0:6])
if XS == 0:
ax4.set_xlim(Sub.XSname[0] - 1, Sub.XSname[-1] + 1)
ax4.set_xticks(Sub.XSname)
else:
ax4.set_xlim(FigureFirstXS, FigureLastXS)
ax4.set_xticks(list(range(FigureFirstXS, FigureLastXS)))
ax4.set_ylim(Sub.crosssections['gl'][FigureFirstXS],
Sub.crosssections['zr'][FigureLastXS] + 5)
#ax4 = fig.add_subplot(gs[0:2,0:6])
ax4.tick_params(labelsize=8)
ax4.plot(Sub.XSname,
Sub.crosssections['zl'],
'k--',
dashes=(5, 1),
linewidth=2,
label='Left Dike')
ax4.plot(Sub.XSname,
Sub.crosssections['zr'],
'k.-',
linewidth=2,
label='Right Dike')
if Sub.Version == 1:
ax4.plot(Sub.XSname,
Sub.crosssections['gl'],
'k-',
linewidth=5,
label='Bankful level')
else:
ax4.plot(Sub.XSname,
Sub.crosssections['gl'],
'k-',
linewidth=5,
label='Ground level')
ax4.plot(Sub.XSname,
Sub.crosssections['gl'] + Sub.crosssections['dbf'],
'k',
linewidth=2,
label='Bankful depth')
ax4.set_title("Water surface Profile Simulation", fontsize=15)
ax4.legend(fontsize=15)
ax4.set_xlabel("Profile", fontsize=15)
ax4.set_ylabel("Elevation m", fontsize=15)
ax4.grid()
if XS == 0:
day_text = ax4.annotate('Begining',
xy=(Sub.XSname[0],
Sub.crosssections['gl'].min()),
fontsize=20)
else:
day_text = ax4.annotate(
'Begining',
xy=(FigureFirstXS + 1,
Sub.crosssections['gl'][FigureLastXS] + 1),
fontsize=20)
WLline, = ax4.plot([], [], linewidth=5)
hLline, = ax4.plot([], [], linewidth=5)
gs.update(wspace=0.2,
hspace=0.2,
top=0.96,
bottom=0.1,
left=0.05,
right=0.96)
# animation
def init_q():
Qline.set_data([], [])
WLline.set_data([], [])
hLline.set_data([], [])
day_text.set_text('')
BC_q_line.set_data([], [])
BC_h_line.set_data([], [])
BC_q_point
BC_h_point
return Qline, WLline, hLline, day_text, BC_q_line, BC_h_line, BC_q_point, BC_h_point
# animation function. this is called sequentially
def animate_q(i):
x = Sub.XSname
y = Sub.Result1D['q'][Sub.Result1D['day'] == counter[i][0]][
Sub.Result1D['hour'] == counter[i][1]].values
day = Sub.ReferenceIndex.loc[counter[i][0], 'date']
day_text.set_text('day = ' +
str(day + dt.timedelta(hours=counter[i][1])))
Qline.set_data(x, y)
y = Sub.Result1D['wl'][Sub.Result1D['day'] == counter[i][0]][
Sub.Result1D['hour'] == counter[i][1]].values
WLline.set_data(x, y)
y = Sub.Result1D['h'][Sub.Result1D['day'] == counter[i][0]][
Sub.Result1D['hour'] == counter[i]
[1]].values * 2 + Sub.crosssections['gl'][
Sub.crosssections.index[len(Sub.XSname) - 1]]
hLline.set_data(x, y)
# BC Q (ax2)
x = Sub.QBC.columns.values
# if XS == 0:
# y = BC_q_T.loc[Qobs.index[counter[i][0]-1]].values
# else:
y = Sub.QBC.loc[Sub.ReferenceIndex.loc[counter[i][0],
'date']].values
BC_q_line.set_data(x, y)
# BC H (ax3)
# if XS == 0:
# y = BC_h_T.loc[Qobs.index[counter[i][0]-1]].values
# else:
y = Sub.HBC.loc[Sub.ReferenceIndex.loc[counter[i][0],
'date']].values
BC_h_line.set_data(x, y)
#BC Q point (ax2)
x = counter[i][1]
# if XS == 0:
# y= Qobs.index[counter[i][0]-1]
# else :
y = Sub.ReferenceIndex.loc[counter[i][0], 'date']
ax2.scatter(x, Sub.QBC[x][y])
#BC h point (ax3)
ax3.scatter(x, Sub.QBC[x][y])
return Qline, WLline, hLline, day_text, BC_q_line, BC_h_line, ax2.scatter(
x, Sub.QBC[x][y], s=300), ax3.scatter(x, Sub.HBC[x][y], s=300)
# plt.tight_layout()
#Writer = animation.FFMpegWriter
#Writer= Writer(fps=30, bitrate=1800, #, metadata=dict(artist='Me')
# extra_args=['-vcodec', 'libx264'])
#animation.FFMpegFileWriter(**kwargs = {"outfile" : 'basic_animation.mp4'})
anim = animation.FuncAnimation(fig,
animate_q,
init_func=init_q,
frames=np.shape(counter)[0],
interval=Interval,
blit=True)
if Save != False:
if Save == "gif":
assert len(Path) >= 1 and Path.endswith(
".gif"), "please enter a valid path to save the animation"
writergif = animation.PillowWriter(fps=SaveFrames)
anim.save(Path, writer=writergif)
else:
try:
if Save == 'avi' or Save == 'mov':
writervideo = animation.FFMpegWriter(fps=SaveFrames,
bitrate=1800)
anim.save(Path, writer=writervideo)
elif Save == 'mp4':
writermp4 = animation.FFMpegWriter(fps=SaveFrames,
bitrate=1800)
anim.save(Path, writer=writermp4)
except FileNotFoundError:
print(
"please visit https://ffmpeg.org/ and download a version of ffmpeg compitable with your operating system, for more details please check the method definition"
)
#anim.save('basic_animation.mp4', writer =Writer) #fps=30,
plt.show()
def wrapper(r_exp_list, position, velocity, k, m, step_size, numsteps):
print("called wrapper") # not Dr. Dre, sadly. I wish I had him on dial.
first_time = time.time(
) # because I have lots of other "start_time" defninitons sprinkled throughout
for n in r_exp_list: # iterate through a list of exponent values for r in newton's law of gravitation
print(
"current job: r**(-", n, ")"
) # when runtimes get long it's nice to know how far through you are
# np.random.seed(1)
# x0 = -2 + 4 * np.random.random((N_trajectories, 3)) # randomizes starting position for each trajectory
# v0 = -1 + 2 * np.random.random((N_trajectories, 3)) # randomizes starting velocity for each trajectory
# p0 = zip(x0,v0) # iterates through and returns x0 and v0 pairs in one tuple, p0. For ease in the list comprehension below.
# arguments for simulate: simulate(position, velocity, k, m, n, step_size, num_steps):
global x_t # so that the animate function can still use this
x_t = np.asarray(
[
backend.simulate(position, velocity, k, m, n, step_size,
numsteps)
]
) # if you're outputting from your own function, make sure that it's an array of position vectors (also arrays!)
# Set up figure & 3D axis for animation
global fig #
fig = plt.figure() #
global ax #
ax = fig.add_axes([0, 0, 1, 1], projection='3d') #
ax.axis(
'on'
) # sets the background axes "on". Change to "off" if you want a more artistic/minimalistic viewing experience
# choose a different color for each trajectory
global colors
colors = plt.cm.jet(np.linspace(0, 1, 1))
# set up lines and points
global lines
lines = sum([ax.plot([], [], [], '-', c=c) for c in colors], [])
global pts
pts = sum([ax.plot([], [], [], 'o', c=c) for c in colors], [])
# prepare the axes limits
ax.set_xlim((-3, 3))
ax.set_ylim((-3, 3))
ax.set_zlim((-3, 3))
# set point-of-view: specified by (altitude degrees, azimuth degrees)
ax.view_init(90, 0)
# instantiate the animator.
start_time = time.time()
anim = animation.FuncAnimation(fig,
animate,
init_func=init,
frames=2000,
interval=1,
blit=True)
print("anim_time is", time.time() - start_time)
start_time = time.time()
plt.show()
mywriter = animation.FFMpegWriter(
bitrate=4000
) # you have to install FFMpeg if you want to write out to mp4
anim.save('single_orbit_n=' + str(n) + 'position_' + str(position) +
'velocity' + str(velocity) + 'timestep' + str(step_size) +
'numsteps' + str(numsteps) + '.mp4',
writer='ffmpeg',
fps=60,
extra_args=['-vcodec',
'libx264']) # autogenerate filenames and export
print("saved the file!")
print("savetime is", time.time() - start_time)
input()
plt.close()
print('combined runtime is', time.time() - first_time)
def animate_tuning(fname_tuning_data,
fname_input_data,
fname_movie_out,
input_data_col=2,
time_mode="real",
fps=30,
label=True,
xlabel="Input"):
"""Generate a movie from the spike raster
Parameters
----------
fname_tuning: string
tuning data filename
first column is the input stimulus used to generate the tuning data
remaining columns are the tuning data
fname_input_data: string
input data filename
first column is sim time
first column is real time
subsequent columns are each inputs dimension
fname_movie_out: string
if string, filename of output movie
nrn_idx: list-like or none
indices of neurons to use to generate wav file
if None, uses all neurons, one per wav file channel
time_mode: "real" or "sim"
Whether to use the spike's real or simulation time
fps: int
frames per second
label: boolean
whether or not to label the tuning curves and display a legend
xlabel: string
x axis label
"""
fig, ax = plot_tuning(fname_tuning_data,
show=False,
label=label,
xlabel=xlabel)
ylim = ax.get_ylim()
file_data = np.loadtxt(fname_input_data)
sim_time = file_data[:, 0]
real_time = file_data[:, 1]
input_data = file_data[:, input_data_col]
if time_mode == "real":
time = real_time
elif time_mode == "sim":
time = sim_time
n_frames = int(np.round(time[-1] * fps))
time_idx = 0
len_time = len(time)
in_dat_line = ax.plot([input_data[time_idx], input_data[time_idx]],
[ylim[0], ylim[1]], 'r:')[0]
ax.set_ylim(ylim)
moviewriter = animation.FFMpegWriter(fps=fps)
with moviewriter.saving(fig, fname_movie_out, dpi=100):
for frame_idx in range(n_frames):
curr_time = frame_idx / fps
moved = False
while time[time_idx] <= curr_time:
time_idx += 1
moved = True
if moved:
time_idx -= 1
if time_idx < len_time:
in_dat_line.set_data(
[input_data[time_idx], input_data[time_idx]],
[ylim[0], ylim[1]])
moviewriter.grab_frame()
def main(unused_argv):
tic = time.time()
inFile = Path(FLAGS.fileName).absolute()
env = jeffRat.mocap() #SET SKELETON/ENVIRONMENT for MOCAP HERE
# data = parse(FLAGS.fileName, FLAGS.varName) # Parse specified clip.
data = parse(os.fspath(FLAGS.fileName),
FLAGS.varName) # Parse specified clip.
max_frame = min(FLAGS.max_frame, data.mocap_pos.shape[0])
frame_step = int(data.fpsIn // FLAGS.fpsOut)
max_num_frames = (max_frame - FLAGS.start_frame) // frame_step + 1
qpos = np.zeros((max_num_frames, env.physics.data.qpos.size),
dtype=np.float64)
qvel = np.zeros((max_num_frames, env.physics.data.qvel.size),
dtype=np.float64)
qacc = np.zeros((max_num_frames, env.physics.data.qacc.size),
dtype=np.float64)
xpos = np.zeros((max_num_frames, env.physics.data.xpos.shape[0],
env.physics.data.xpos.shape[1]),
dtype=np.float64)
tendonLen = np.zeros((max_num_frames, env.physics.data.ten_length.size),
dtype=np.float64)
tendonVel = np.zeros((max_num_frames, env.physics.data.ten_velocity.size),
dtype=np.float64)
badFrame = []
if FLAGS.play or FLAGS.record or not FLAGS.qOnly:
# Set up formatting for the movie files
video = np.zeros((max_num_frames, height, width, 3), dtype=np.uint8)
if FLAGS.record:
metadata = dict(title=FLAGS.model_filename + ': ' + FLAGS.fileName,
artist='Jeff Rhoades/Jesse Marshall/DeepMind',
comment=FLAGS.varName)
writer = animation.FFMpegWriter(fps=FLAGS.fpsOut,
metadata=metadata,
bitrate=-1)
print('Getting video......', end='')
if FLAGS.silent:
for i in range(FLAGS.start_frame, max_frame, frame_step):
i1 = (i - FLAGS.start_frame) // frame_step
if FLAGS.play or FLAGS.record or not FLAGS.qOnly:
video[i1], qpos[i1], tendonLen[i1], tendonVel[i1], bF, qvel[
i1], qacc[i1], xpos[i1] = getFrame(data, env, i)
else:
qpos[i1], tendonLen[i1], tendonVel[i1], bF, qvel[i1], qacc[
i1], xpos[i1] = getJoints(data, env, i)
badFrame.append(bF)
else:
with progressbar.ProgressBar(max_value=max_num_frames,
poll_interval=5) as bar:
for i in range(FLAGS.start_frame, max_frame, frame_step):
i1 = (i - FLAGS.start_frame) // frame_step
if FLAGS.play or FLAGS.record or not FLAGS.qOnly:
video[i1], qpos[i1], tendonLen[i1], tendonVel[
i1], bF, qvel[i1], qacc[i1], xpos[i1] = getFrame(
data, env, i)
else:
qpos[i1], tendonLen[i1], tendonVel[i1], bF, qvel[i1], qacc[
i1], xpos[i1] = getJoints(data, env, i)
badFrame.append(bF)
bar.update(i1)
print('...done.')
toc = time.time() - tic
vid_dt = max_num_frames // FLAGS.fpsOut
print('%.2f x real speed' % (toc / vid_dt))
print(str(sum(badFrame)) + ' bad frames.')
if FLAGS.save:
qnames = []
qnames[:5] = [env.physics.named.data.qpos.axes[0].names[0]
] * 6 #First 7 are pos and quaternion of root frame
qnames.extend(env.physics.named.data.qpos.axes[0].names)
tendonNames = env.physics.named.data.ten_length.axes[0].names
out = dict()
out['qpos'] = qpos
out['qvel'] = qvel
out['qacc'] = qacc
out['xpos'] = xpos
out['qnames'] = qnames
out['tendonLen'] = tendonLen
out['tendonVel'] = tendonVel
out['tendonNames'] = tendonNames
out['fpsIn'] = data.fpsIn
out['fpsOut'] = FLAGS.fpsOut
out['badFrame'] = badFrame
out['mocap_pos'] = data.mocap_pos
out['markerNames'] = data.bods
out['model'] = FLAGS.model_filename
out['medianPose'] = data.medianPose
today = datetime.datetime.today()
path = inFile.parents[1]
modelFile = Path(FLAGS.model_filename)
if FLAGS.play or FLAGS.record or not FLAGS.qOnly:
out['vid'] = video
if FLAGS.outName:
outName = FLAGS.outName
else:
outName = os.fspath(
Path(
path, "dataOutput", inFile.stem + "_via_" +
modelFile.stem + "_" + str(FLAGS.start_frame) + "_thru_" +
str(max_frame) + "_fps" + str(FLAGS.fpsOut) + "_" +
today.strftime('%Y%m%d_%H%M')))
print('Saving Matlab file to ' + outName +
'................................................')
try:
sio.savemat(outName, out, do_compression=True)
print('done.')
except:
print('failed.')
if FLAGS.play:
fig = plt.figure()
plt.waitforbuttonpress()
ticky = time.time()
for i in range(video.shape[0]):
if i == 0:
img = plt.imshow(video[i])
else:
img.set_data(video[i])
fig.canvas.flush_events()
clock_dt = time.time() - ticky
ticky = time.time()
# Real-time playback not always possible as clock_dt > .03
plt.draw()
time.sleep(max(0.01, 1 / FLAGS.fpsOut - clock_dt))
# plt.pause(max(0.01, 1/fpsOut - clock_dt)) # Need min display time > 0.0.
plt.waitforbuttonpress()
if FLAGS.record:
print('Saving mp4', end='')
try:
fig = plt.figure()
img = plt.imshow(video[0])
plt.rcParams[
'animation.ffmpeg_path'] = r'C:\Users\RatControl\ffmpeg\bin\ffmpeg.exe'
with writer.saving(fig, outName + '.mp4', dpi=FLAGS.dpi):
for i in range(video.shape[0]):
img.set_data(video[i])
plt.draw()
writer.grab_frame()
print('.', end='')
writer.finish()
print('done.')
except:
print('.......failed.')
# ===========================================================
for i in range(0, 50):
u[0][i] = 1.0
for k in range(1, rows):
u[k][0] = 1.0
f = 100
# ===========================================================
for m in range(1, rows):
for n in range(1, cols - 1):
# predictor
ubar = u[m - 1][n] - 0.5 * h * ((u[m - 1][n + 1])**2 -
(u[m - 1][n]**2))
# corrector
fbar = 0.5 * (ubar**2)
fbarm = 0.5 * (u[m][n - 1]**2)
u[m][n] = 0.5 * (u[m - 1][n] + ubar - h * (fbar - fbarm))
#ax.plot(u[100][0:101], x[0:101], c='k')
anim = animation.FuncAnimation(fig,
animate,
init_func=init,
interval=10,
frames=f)
mywriter = animation.FFMpegWriter(fps=10, codec="libx264")
anim.save('mac2.mp4', writer=mywriter)
plt.draw()
plt.show()
('\n'
'FFMpegWriter block taken from:\n'
'https://github.com/BV-DR/foamBazar/blob/master/pythonScripts/waveProbesPP.py\n'
)
def render(self, mode="video", output_file=None):
from matplotlib import animation
import matplotlib.pyplot as plt
# plt.rcParams['animation.ffmpeg_path'] = '/usr/bin/ffmpeg'
x_offset = 0.2
y_offset = 0.4
cmap = plt.cm.get_cmap("hsv", 10)
robot_color = "black"
arrow_style = patches.ArrowStyle("->", head_length=4, head_width=2)
display_numbers = True
if mode == "traj":
fig, ax = plt.subplots(figsize=(7, 7))
ax.tick_params(labelsize=16)
ax.set_xlim(-5, 5)
ax.set_ylim(-5, 5)
ax.set_xlabel("x(m)", fontsize=16)
ax.set_ylabel("y(m)", fontsize=16)
# add human start positions and goals
human_colors = [cmap(i) for i in range(len(self.humans))]
for i in range(len(self.humans)):
human = self.humans[i]
human_goal = mlines.Line2D(
[human.get_goal_position()[0]],
[human.get_goal_position()[1]],
color=human_colors[i],
marker="*",
linestyle="None",
markersize=15,
)
ax.add_artist(human_goal)
human_start = mlines.Line2D(
[human.get_start_position()[0]],
[human.get_start_position()[1]],
color=human_colors[i],
marker="o",
linestyle="None",
markersize=15,
)
ax.add_artist(human_start)
robot_positions = [
self.states[i][0].position for i in range(len(self.states))
]
human_positions = [
[self.states[i][1][j].position for j in range(len(self.humans))]
for i in range(len(self.states))
]
for k in range(len(self.states)):
if k % 4 == 0 or k == len(self.states) - 1:
robot = plt.Circle(
robot_positions[k],
self.robot.radius,
fill=False,
color=robot_color,
)
humans = [
plt.Circle(
human_positions[k][i],
self.humans[i].radius,
fill=False,
color=cmap(i),
)
for i in range(len(self.humans))
]
ax.add_artist(robot)
for human in humans:
ax.add_artist(human)
# add time annotation
global_time = k * self.time_step
if global_time % 4 == 0 or k == len(self.states) - 1:
agents = humans + [robot]
times = [
plt.text(
agents[i].center[0] - x_offset,
agents[i].center[1] - y_offset,
"{:.1f}".format(global_time),
color="black",
fontsize=14,
)
for i in range(self.human_num + 1)
]
for time in times:
ax.add_artist(time)
if k != 0:
nav_direction = plt.Line2D(
(self.states[k - 1][0].px, self.states[k][0].px),
(self.states[k - 1][0].py, self.states[k][0].py),
color=robot_color,
ls="solid",
)
human_directions = [
plt.Line2D(
(self.states[k - 1][1][i].px, self.states[k][1][i].px),
(self.states[k - 1][1][i].py, self.states[k][1][i].py),
color=cmap(i),
ls="solid",
)
for i in range(self.human_num)
]
ax.add_artist(nav_direction)
for human_direction in human_directions:
ax.add_artist(human_direction)
plt.legend([robot], ["Robot"], fontsize=16)
plt.show()
elif mode == "video":
fig, ax = plt.subplots(figsize=(7, 7))
ax.tick_params(labelsize=12)
ax.set_xlim(-11, 11)
ax.set_ylim(-11, 11)
ax.set_xlabel("x(m)", fontsize=14)
ax.set_ylabel("y(m)", fontsize=14)
show_human_start_goal = False
# add human start positions and goals
human_colors = [cmap(i) for i in range(len(self.humans))]
if show_human_start_goal:
for i in range(len(self.humans)):
human = self.humans[i]
human_goal = mlines.Line2D(
[human.get_goal_position()[0]],
[human.get_goal_position()[1]],
color=human_colors[i],
marker="*",
linestyle="None",
markersize=8,
)
ax.add_artist(human_goal)
human_start = mlines.Line2D(
[human.get_start_position()[0]],
[human.get_start_position()[1]],
color=human_colors[i],
marker="o",
linestyle="None",
markersize=8,
)
ax.add_artist(human_start)
# add robot start position
robot_start = mlines.Line2D(
[self.robot.get_start_position()[0]],
[self.robot.get_start_position()[1]],
color=robot_color,
marker="o",
linestyle="None",
markersize=8,
)
robot_start_position = [
self.robot.get_start_position()[0],
self.robot.get_start_position()[1],
]
ax.add_artist(robot_start)
# add robot and its goal
robot_positions = [state[0].position for state in self.states]
goal = mlines.Line2D(
[self.robot.get_goal_position()[0]],
[self.robot.get_goal_position()[1]],
color=robot_color,
marker="*",
linestyle="None",
markersize=15,
label="Goal",
)
robot = plt.Circle(
robot_positions[0], self.robot.radius, fill=False, color=robot_color
)
# sensor_range = plt.Circle(robot_positions[0], self.robot_sensor_range, fill=False, ls='dashed')
ax.add_artist(robot)
ax.add_artist(goal)
plt.legend([robot, goal], ["Robot", "Goal"], fontsize=14)
# add humans and their numbers
human_positions = [
[state[1][j].position for j in range(len(self.humans))]
for state in self.states
]
humans = [
plt.Circle(
human_positions[0][i],
self.humans[i].radius,
fill=False,
color=cmap(i),
)
for i in range(len(self.humans))
]
# disable showing human numbers
if display_numbers:
human_numbers = [
plt.text(
humans[i].center[0] - x_offset,
humans[i].center[1] + y_offset,
str(i),
color="black",
)
for i in range(len(self.humans))
]
for i, human in enumerate(humans):
ax.add_artist(human)
if display_numbers:
ax.add_artist(human_numbers[i])
# add time annotation
time = plt.text(
0.4, 0.9, "Time: {}".format(0), fontsize=16, transform=ax.transAxes
)
ax.add_artist(time)
# visualize attention scores
# if hasattr(self.robot.policy, 'get_attention_weights'):
# attention_scores = [
# plt.text(-5.5, 5 - 0.5 * i, 'Human {}: {:.2f}'.format(i + 1, self.attention_weights[0][i]),
# fontsize=16) for i in range(len(self.humans))]
# compute orientation in each step and use arrow to show the direction
radius = self.robot.radius
orientations = []
for i in range(self.human_num + 1):
orientation = []
for state in self.states:
agent_state = state[0] if i == 0 else state[1][i - 1]
if self.robot.kinematics == "unicycle" and i == 0:
direction = (
(agent_state.px, agent_state.py),
(
agent_state.px + radius * np.cos(agent_state.theta),
agent_state.py + radius * np.sin(agent_state.theta),
),
)
else:
theta = np.arctan2(agent_state.vy, agent_state.vx)
direction = (
(agent_state.px, agent_state.py),
(
agent_state.px + radius * np.cos(theta),
agent_state.py + radius * np.sin(theta),
),
)
orientation.append(direction)
orientations.append(orientation)
if i == 0:
arrow_color = "black"
arrows = [
patches.FancyArrowPatch(
*orientation[0], color=arrow_color, arrowstyle=arrow_style
)
]
else:
arrows.extend(
[
patches.FancyArrowPatch(
*orientation[0],
color=human_colors[i - 1],
arrowstyle=arrow_style
)
]
)
for arrow in arrows:
ax.add_artist(arrow)
global_step = 0
if len(self.trajs) != 0:
human_future_positions = []
human_future_circles = []
for traj in self.trajs:
human_future_position = [
[
tensor_to_joint_state(traj[step + 1][0])
.human_states[i]
.position
for step in range(self.robot.policy.planning_depth)
]
for i in range(self.human_num)
]
human_future_positions.append(human_future_position)
for i in range(self.human_num):
circles = []
for j in range(self.robot.policy.planning_depth):
circle = plt.Circle(
human_future_positions[0][i][j],
self.humans[0].radius / (1.7 + j),
fill=False,
color=cmap(i),
)
ax.add_artist(circle)
circles.append(circle)
human_future_circles.append(circles)
def update(frame_num):
nonlocal global_step
nonlocal arrows
global_step = frame_num
robot.center = robot_positions[frame_num]
for i, human in enumerate(humans):
human.center = human_positions[frame_num][i]
if display_numbers:
human_numbers[i].set_position(
(human.center[0] - x_offset, human.center[1] + y_offset)
)
for arrow in arrows:
arrow.remove()
for i in range(self.human_num + 1):
orientation = orientations[i]
if i == 0:
arrows = [
patches.FancyArrowPatch(
*orientation[frame_num],
color="black",
arrowstyle=arrow_style
)
]
else:
arrows.extend(
[
patches.FancyArrowPatch(
*orientation[frame_num],
color=cmap(i - 1),
arrowstyle=arrow_style
)
]
)
for arrow in arrows:
ax.add_artist(arrow)
# if hasattr(self.robot.policy, 'get_attention_weights'):
# attention_scores[i].set_text('human {}: {:.2f}'.format(i, self.attention_weights[frame_num][i]))
time.set_text("Time: {:.2f}".format(frame_num * self.time_step))
if len(self.trajs) != 0:
for i, circles in enumerate(human_future_circles):
for j, circle in enumerate(circles):
circle.center = human_future_positions[global_step][i][j]
def plot_value_heatmap():
if self.robot.kinematics != "holonomic":
print("Kinematics is not holonomic")
return
# for agent in [self.states[global_step][0]] + self.states[global_step][1]:
# print(('{:.4f}, ' * 6 + '{:.4f}').format(agent.px, agent.py, agent.gx, agent.gy,
# agent.vx, agent.vy, agent.theta))
# when any key is pressed draw the action value plot
fig, axis = plt.subplots()
speeds = [0] + self.robot.policy.speeds
rotations = self.robot.policy.rotations + [np.pi * 2]
r, th = np.meshgrid(speeds, rotations)
z = np.array(self.action_values[global_step % len(self.states)][1:])
z = (z - np.min(z)) / (np.max(z) - np.min(z))
z = np.reshape(
z,
(
self.robot.policy.rotation_samples,
self.robot.policy.speed_samples,
),
)
polar = plt.subplot(projection="polar")
polar.tick_params(labelsize=16)
mesh = plt.pcolormesh(th, r, z, vmin=0, vmax=1)
plt.plot(rotations, r, color="k", ls="none")
plt.grid()
cbaxes = fig.add_axes([0.85, 0.1, 0.03, 0.8])
cbar = plt.colorbar(mesh, cax=cbaxes)
cbar.ax.tick_params(labelsize=16)
plt.show()
def print_matrix_A():
# with np.printoptions(precision=3, suppress=True):
# print(self.As[global_step])
h, w = self.As[global_step].shape
print(" " + " ".join(["{:>5}".format(i - 1) for i in range(w)]))
for i in range(h):
print(
"{:<3}".format(i - 1)
+ " ".join(
[
"{:.3f}".format(self.As[global_step][i][j])
for j in range(w)
]
)
)
# with np.printoptions(precision=3, suppress=True):
# print('A is: ')
# print(self.As[global_step])
def print_feat():
with np.printoptions(precision=3, suppress=True):
print("feat is: ")
print(self.feats[global_step])
def print_X():
with np.printoptions(precision=3, suppress=True):
print("X is: ")
print(self.Xs[global_step])
def on_click(event):
if anim.running:
anim.event_source.stop()
if event.key == "a":
if hasattr(self.robot.policy, "get_matrix_A"):
print_matrix_A()
if hasattr(self.robot.policy, "get_feat"):
print_feat()
if hasattr(self.robot.policy, "get_X"):
print_X()
# if hasattr(self.robot.policy, 'action_values'):
# plot_value_heatmap()
else:
anim.event_source.start()
anim.running ^= True
fig.canvas.mpl_connect("key_press_event", on_click)
anim = animation.FuncAnimation(
fig, update, frames=len(self.states), interval=self.time_step * 500
)
anim.running = True
if output_file is not None:
# save as video
ffmpeg_writer = animation.FFMpegWriter(
fps=10, metadata=dict(artist="Me"), bitrate=1800
)
# writer = ffmpeg_writer(fps=10, metadata=dict(artist='Me'), bitrate=1800)
anim.save(output_file, writer=ffmpeg_writer)
# save output file as gif if imagemagic is installed
# anim.save(output_file, writer='imagemagic', fps=12)
else:
plt.show()
else:
raise NotImplementedError
elif plot_histograms:
Writer = animation.writers['ffmpeg']
writer = Writer(fps=15, metadata=dict(artist='Me'), bitrate=1800)
fname = f'./Figures/KDE_Histograms_bp_distribution_BN(AFTER_RELU)_H={H}_T={NumIters}_lr={learning_rate}_N={N}_Activation={activationFunc}_Initialization = {initFunc}_minibatch = {mini_batch_option}_bin_width = 0.1_2'
ani.save(fname + '.mp4', writer=writer)
show()
elif plot_loss:
fname = f'./Figures/semigLog_BN(before RELU)_Training_loss_vs_time_fitted_nn_snapshots_H={H}_T={NumIters}_lr={learning_rate}_N={N}_Activation={activationFunc}_Initialization = {initFunc}_minibatch = {mini_batch_option}.pdf'
xlabel('Epoch')
ylabel('Loss')
elif makeVid:
mywriter = animation.FFMpegWriter(fps=10,
metadata=dict(artist='Me'),
bitrate=18000)
# fname = f'./Figures/Animated_curve_fitted_nn_snapshots_H={H}_T={NumIters}_lr={learning_rate}_N={N}_Activation={activationFunc}_Initialization = {initFunc}_minibatch = {mini_batch_option}_'+tag + f'percent_prune= {percent}'
fname = './Figures/' + tag #change later
ani = animation.ArtistAnimation(fig,
ims,
interval=50,
blit=True,
repeat_delay=1000)
ani.save(fname + '.mp4', writer=mywriter)
# print(fname)
fname = './Figures/' + tag
if not makeVid:
savefig(fname)
print(fname)
def saveAnimationToFile(self):
self.writer = anim.FFMpegWriter(fps=15, bitrate=5000)
self.animHandler.save("t.mp4", writer=self.writer)
return
ax2.figure.canvas.draw()
ymin, ymax = ax2.get_ylim()
if history['cost'][i] >= ymax:
ax2.set_ylim(ymin, history['cost'][i] + 0.5)
ax2.figure.canvas.draw()
elif history["cost"][i] < ymin:
ax2.set_xlim(ymin / 2, ymax)
ax2.figure.canvas.draw()
line1.set_data(X, prediction)
line2.set_data(x_cost, y_cost)
return line1, line2
ani = animation.FuncAnimation(fig,
animate,
init_func=init,
frames=len(y_pred),
blit=True,
interval=1,
repeat=False)
# saves the animation as .mp4 (takes time, comment if needed)
mywriter = animation.FFMpegWriter(fps=60)
ani.save(f'{name} Gradient Descent.mp4', writer=mywriter)
# show the animation
plt.show()
def run_odex_convection_2d(config, do_plot, outfile=None):
print('odex: 2D convection...')
# PDE initial data
npoints = 64
xx = np.linspace(0,npoints-1,npoints, dtype=np.float64)
xx,yy = np.meshgrid(xx,xx)
u0 = np.exp(-60*((xx/npoints-.5)**2+(yy/npoints-.5)**2))
# PDE and solver parameters
c = [0.5, 0.25] # Wave speed
k = 1. # Unit grid spacing
t0 = 0. # Simulation start time
nsteps = 2048 # Number of time steps
spectral = True
# Movie writer setup
if outfile is not None:
moviewriter = anim.FFMpegWriter(fps=30)
fig = plt.figure()
ax = fig.gca(projection='3d')
moviewriter.setup(fig, outfile, dpi=100)
def observer(t,state):
ax.clear()
ax.plot_wireframe(xx, yy, state)
ax.set_zlim(0,1)
moviewriter.grab_frame()
else:
observer = None
# Spectral gradient helper
def islope():
n = len(u0);
kn = 2.*np.pi/n/k;
iw = 1j*kn*np.array(list(range(0, int(n/2)+1)) + list(range(-int(n/2)+1,0)))
return np.meshgrid(iw, iw)
ikx, iky = islope()
def spectral_gradient(u, k):
U = np.fft.fft2(u)
return np.real(np.fft.ifft2(ikx*U)), np.real(np.fft.ifft2(iky*U))
def central_difference(u, k):
n = len(u)
ux = np.empty(np.shape(u))
uy = np.empty(np.shape(u))
ux[:,1:n-1] = (u[:,2:n]-u[:,:n-2])/(2*k)
ux[:,0 ] = (u[:,1 ]-u[:, n-1])/(2*k)
ux[:,n-1 ] = (u[:,0 ]-u[:, n-2])/(2*k)
uy[1:n-1,:] = (u[2:n,:]-u[:n-2,:])/(2*k)
uy[0, :] = (u[1, :]-u[ n-1,:])/(2*k)
uy[n-1, :] = (u[0, :]-u[ n-2,:])/(2*k)
return ux, uy
if spectral:
derivfn = spectral_gradient
else:
derivfn = central_difference
def gradient(u, k):
return derivfn(u, k)
# PDE system: transport
def system(t, u):
ux,uy = gradient(u, k)
ut = -c[0]*ux-c[1]*uy
return ut
# Construct the extrapolation stepper
stepper = odex.make_extrapolation_stepper(system, u0, config=config, parallel=True)
# Set up maximum time step size
hmax = k*(max(stepper.stepcounts)+1)*stepper.isbn/(2*max(c))
if spectral: hmax = hmax/np.pi
dt = hmax*.99
# Step the system once to ensure one-time setup completes before profiling
stepper.step(u0, t0, dt, 1, dense_output=None, observer=None)
# Solve the system, profiling
start = time.time()
un = stepper.step(u0, t0, dt, nsteps, dense_output=None, observer=observer)
duration = time.time()-start
stepper.join()
if outfile is not None:
moviewriter.finish()
plt.close()
# Compute the error, print the results
print(' duration: {}'.format(duration))
# Compute the mean evaluation time of the PDE system
iters = 100
mean_eval_time = 0
for ii in range(iters):
start = time.time()
system(t0,u0)
mean_eval_time += time.time()-start
mean_eval_time /= iters
# Print the profiling results
estimated_duration = nsteps*np.sum(np.array(stepper.stepcounts)+1)*mean_eval_time
print(' mean eval duration: {}'.format(mean_eval_time))
print(' estimated duration: {}'.format(estimated_duration))
print(' efficiency: {0:.2f}%'.format(100*estimated_duration/duration))
# Plot initial and final transport results
if do_plot:
fig = plt.figure()
ax = fig.gca(projection='3d')
ax.plot_wireframe(xx, yy, u0)
fig = plt.figure()
ax = fig.gca(projection='3d')
ax.plot_wireframe(xx, yy, un)
plt.grid()
plt.show()
return duration
def next_gen(arr):
"""
This function applies Conway's rules and creates the next generation.
"""
sum_of_neighbors = ndimage.convolve(
grid, kernel,
mode='constant') #computes the sum of the eight neighbors of each cell
born = (sum_of_neighbors == 3) & (
grid == 0) #rule if dead cell has 3 alive neighbors it becomes alive
die = ((sum_of_neighbors < 2) | (sum_of_neighbors > 3)) & (
grid == 1
) #rule if live cell does not have exactly 2 or 3 live neighbors it dies
grid[born] = 1 #apply the rules to the grid
grid[die] = 0
ax.imshow(
grid, cmap='viridis'
) #shows image of numpy array holding the state of the environment
ax.grid(False)
anim = animation.FuncAnimation(fig, next_gen, interval=10,
frames=100) #animates the game
plt.xticks([])
plt.yticks([])
plt.title('Conway\'s Game Of Life \n Programmed by Sydney Riemer')
plt.show()
FFwriter = animation.FFMpegWriter(fps=5)
f = r'C:\\Users\\sydne\\Desktop\\Riemer_Assignment4_P1.avi'
anim.save(f, writer=FFwriter)
def run_simulation(self):
self.people = [
Person('Normal', self.total_size, self.recover_period,
self.mortality) for i in range(self.population)
]
if self.social_spacing:
people_ss = self.people[-self.social_spacing:]
for person in self.people:
if person in people_ss:
person.social_space()
self.people[0].contaminate()
self.fig = plt.figure()
self.ax = plt.axes(xlim=(0, self.total_size),
ylim=(0, self.total_size))
plt.xticks([])
plt.yticks([])
self.d_sick, = self.ax.plot([
person.position_x
for person in self.people if person.status == 'Sick'
], [
person.position_y
for person in self.people if person.status == 'Sick'
], 'ro')
self.d_recovered, = self.ax.plot([
person.position_x
for person in self.people if person.status == 'Recovered'
], [
person.position_y
for person in self.people if person.status == 'Recovered'
], 'yo')
self.d_healthy, = self.ax.plot([
person.position_x
for person in self.people if person.status == 'Healthy'
], [
person.position_y
for person in self.people if person.status == 'Healthy'
], 'bo')
self.d_dead, = self.ax.plot([
person.position_x
for person in self.people if person.status == 'Dead'
], [
person.position_y
for person in self.people if person.status == 'Dead'
], 'ko')
self.d = [self.d_sick, self.d_healthy, self.d_recovered]
sick = len(self.d_sick.get_data()[0])
healthy = len(self.d_healthy.get_data()[0])
recovered = len(self.d_recovered.get_data()[0])
dead = len(self.d_dead.get_data()[0])
self.data = []
self.data.append([sick, healthy, recovered, dead])
self.end_animation = False
def animate(i):
# self.people = contamination(self.people,self.contamination_rate)
self.contamination()
for person in self.people:
person.update_position()
if self.end_animation:
plt.close()
if len([x for x in self.people if x.is_contaminated()]) == 0:
for person in self.people:
person.stop()
self.end_animation = True
self.d_sick.set_data([
person.position_x
for person in self.people if person.status == 'Sick'
], [
person.position_y
for person in self.people if person.status == 'Sick'
])
self.d_recovered.set_data(
[
person.position_x
for person in self.people if person.status == 'Recovered'
],
[
person.position_y
for person in self.people if person.status == 'Recovered'
],
)
self.d_healthy.set_data([
person.position_x
for person in self.people if person.status == 'Healthy'
], [
person.position_y
for person in self.people if person.status == 'Healthy'
])
self.d_dead.set_data([
person.position_x
for person in self.people if person.status == 'Dead'
], [
person.position_y
for person in self.people if person.status == 'Dead'
])
sick = len(self.d_sick.get_data()[0])
healthy = len(self.d_healthy.get_data()[0])
recovered = len(self.d_recovered.get_data()[0])
dead = len(self.d_dead.get_data()[0])
self.data.append([sick, healthy, recovered, dead])
print(
'{} -> Sick: {}, Healthy: {}, Recovered: {}, Dead: {}, Probability: {}'
.format(i, sick, healthy, recovered, dead,
(3 * dead + sick) / (self.population)))
return self.d,
anim = FuncAnimation(self.fig, animate, frames=10000, interval=20)
if self.output_filename:
mywriter = animation.FFMpegWriter(fps=60)
try:
output_file = self.output_filename + '_SimulationVideo.mp4' ()
anim.save(output_file, writer=mywriter)
except:
print(
'An error occurred while trying to save the simulation video'
)
plt.show()
#!/usr/bin/python3
import scipy
from scipy.io import wavfile
import numpy as np
import utils
import matplotlib.pyplot as plt
import matplotlib.animation as animation
FPS = 30
plt.style.use('dark_background')
fig, ax = plt.subplots()
fw = animation.FFMpegWriter(FPS)
fig.set_size_inches(192, 27)
sample_rate, data = wavfile.read('alone.wav')
#mono = (data.T[0] + data.T[1]) / 2.0 # average stereo into mono
left = data.T[0]
right = data.T[1]
secs = int(len(left) / sample_rate)+1
spf = int(sample_rate / FPS)
q = sample_rate / spf
with fw.saving(fig, "plot2.mp4", 14):
for frame in range(secs * FPS):
print(frame)
ax.clear()
ax.axis('off')
ax.set_ylim(-30000, 30000)
from utilities.stack_decoder import decode_cp
from matplotlib import pyplot as plt
from matplotlib import animation
from utilities.cpHMM_BW import cpEM_BW
import time
#Set Paths
root = "../results"
folder = "method_validation"
subfolder = "BW_PDF_Animation"
outpath = os.path.join(root, folder, subfolder)
plt.rcParams[
'animation.ffmpeg_path'] = 'C:\\Users\\Nicholas\\Downloads\\ffmpeg\\ffmpeg\\bin\\ffmpeg.exe'
FFwriter = animation.FFMpegWriter()
out_name = 'bw_test'
# memory
w = 4
# Fix 5race length for now
T = 200
# Number of traces per batch
batch_size = 20
R = np.array([[-.008, .009, .01], [.006, -.014, .025], [.002, .005, -.035]
]) * 10.2
A = sp.linalg.expm(R, q=None)
print(A)
pi = [.2, .3, .5]
v = np.array([0.0, 25.0, 100.0])
ims[1].set_data(E_vel[0].T)
ims[2].set_data(E_acc[0].T)
ims[3].set_data(E_total[1].T)
ims[4].set_data(E_vel[1].T)
ims[5].set_data(E_acc[1].T)
ims[6].set_data(E_total[2].T)
ims[7].set_data(E_vel[2].T)
ims[8].set_data(E_acc[2].T)
ims[9].set_data(B_total[0].T)
ims[10].set_data(B_vel[0].T)
ims[11].set_data(B_acc[0].T)
ims[12].set_data(B_total[1].T)
ims[13].set_data(B_vel[1].T)
ims[14].set_data(B_acc[1].T)
ims[15].set_data(B_total[2].T)
ims[16].set_data(B_vel[2].T)
ims[17].set_data(B_acc[2].T)
return ims,
def _init_animate():
"""Necessary for matplotlib animate."""
pass
dt = 2*np.pi/charges[0].w/24
ani = FuncAnimation(fig, _update_animation, interval=1000/24,
frames=240, blit=False, init_func=_init_animate)
ani.save('Animations/'+savename+'.mp4',
writer=animation.FFMpegWriter(fps=24), dpi=500)
#### initialize
## grid initialized with A = 1, B = 0 & small area B = 1
## Laplacian with 3x3 convolution with:
## --> center weight: -1
## --> adjacent neighbors: .2
## --> diagonals = .05
# values for kernel
w_c = -1
w_a = 0.2
w_d = 0.05
# kernel
laplace_kernel = np.asarray([[w_d, w_a, w_d], [w_a, w_c, w_a], [w_d, w_a, w_d]])
# starting matrices
A, B = starting_mat2(N = N)
# run simulations
ims = update_n2(A, B, laplace_kernel, t = t, n_sim = n_sim, N = N)
# show animation
ani = animation.ArtistAnimation(fig, ims, interval=50, blit=True,
repeat_delay=300)
writervideo = animation.FFMpegWriter(fps=20)
ani.save(filename = "anims/test3.mp4", writer=writervideo)
# plt show
#plt.show()
