def animate_emission(hmm, obs_map, M=8, height=12, width=12, delay=1):
# Parameters.
lim = 1200
text_x_offset = 40
text_y_offset = 80
x_offset = 580
y_offset = 520
R = 420
r = 100
arrow_size = 20
arrow_p1 = 0.03
arrow_p2 = 0.02
arrow_p3 = 0.06
# Initialize.
n_states = len(hmm.A)
obs_map_r = obs_map_reverser(obs_map)
wordclouds = states_to_wordclouds(hmm, obs_map, max_words=20, show=False)
# Initialize plot.
fig, ax = plt.subplots()
fig.set_figheight(height)
fig.set_figwidth(width)
ax.grid('off')
plt.axis('off')
ax.set_xlim([0, lim])
ax.set_ylim([0, lim])
# Plot each wordcloud.
for i, wordcloud in enumerate(wordclouds):
x = x_offset + int(R * np.cos(np.pi * 2 * i / n_states))
y = y_offset + int(R * np.sin(np.pi * 2 * i / n_states))
ax.imshow(wordcloud.to_array(),
extent=(x - r, x + r, y - r, y + r),
aspect='auto',
zorder=-1)
# Initialize text.
text = ax.text(text_x_offset, lim - text_y_offset, '', fontsize=24)
# Make the arrows.
zorder_mult = n_states**2 * 100
arrows = []
for i in range(n_states):
row = []
for j in range(n_states):
# Arrow coordinates.
x_i = x_offset + R * np.cos(np.pi * 2 * i / n_states)
y_i = y_offset + R * np.sin(np.pi * 2 * i / n_states)
x_j = x_offset + R * np.cos(np.pi * 2 * j / n_states)
y_j = y_offset + R * np.sin(np.pi * 2 * j / n_states)
dx = x_j - x_i
dy = y_j - y_i
d = np.sqrt(dx**2 + dy**2)
if i != j:
arrow = ax.arrow(x_i + (r / d + arrow_p1) * dx + arrow_p2 * dy,
y_i + (r / d + arrow_p1) * dy + arrow_p2 * dx,
(1 - 2 * r / d - arrow_p3) * dx,
(1 - 2 * r / d - arrow_p3) * dy,
color=(1 - hmm.A[i][j], ) * 3,
head_width=arrow_size,
head_length=arrow_size,
zorder=int(hmm.A[i][j] * zorder_mult))
else:
arrow = ax.arrow(x_i,
y_i,
0,
0,
color=(1 - hmm.A[i][j], ) * 3,
head_width=arrow_size,
head_length=arrow_size,
zorder=int(hmm.A[i][j] * zorder_mult))
row.append(arrow)
arrows.append(row)
emission, states = hmm.generate_emission(M)
def animate(i):
if i >= delay:
i -= delay
if i == 0:
arrows[states[0]][states[0]].set_color('red')
elif i == 1:
arrows[states[0]][states[0]].set_color(
(1 - hmm.A[states[0]][states[0]], ) * 3)
arrows[states[i - 1]][states[i]].set_color('red')
else:
arrows[states[i - 2]][states[i - 1]].set_color(
(1 - hmm.A[states[i - 2]][states[i - 1]], ) * 3)
arrows[states[i - 1]][states[i]].set_color('red')
# Set text.
text.set_text(' '.join([obs_map_r[e]
for e in emission][:i + 1]).capitalize())
return arrows + [text]
# Animate!
print('\nAnimating...')
anim = FuncAnimation(fig, animate, frames=M + delay, interval=1000)
return anim
parser.add_argument(
"--images",
help="Background activation = 1, ant activation = 2 both = 3",
action="store_true")
args = parser.parse_args()
if not os.path.exists(args.map):
raise IOError("Map file not found")
if args.solution and not os.path.exists(args.solution):
raise IOError("Solution file not found")
data = parse(args.map, args.solution)
# Graph
G = nx.Graph()
G.add_edges_from(data['tunnels'])
# Fruchterman-Reingold force-directed algorithm's to set rooms.
pos = nx.spring_layout(G)
# Ants speed
speed_rate = 7
# create an array of * on the ants object
ants = make_ants(pos, speed_rate, data)
# size of the graph
fig = plt.figure(figsize=(15, 10))
ant_img = read_png('./images/Fourmisse.png')
ani = FuncAnimation(fig,
re_init,
frames=data['num_turns'] * speed_rate,
fargs=(G, pos, speed_rate, data, ants, args, ant_img),
interval=30,
repeat=True)
plt.show()
def init():
line, = ax.plot(dist.pos[0], dist.pos[1])
return line,
def animate(i):
dist.update_pos()
x = dist.pos[0]
y = dist.pos[1]
z = dist.pos[2]
line.set_data(np.asarray([x]), np.asarray([y]))
line.set_3d_properties(np.asarray([z]), 'z')
return line,
ax.set_xlim3d([-5.0, 5.0])
ax.set_ylim3d([-5.0, 5.0])
ax.set_zlim3d([-5.0, 5.0])
ax.axis([-5, 5, -5, 5])
anim = FuncAnimation(fig,
animate,
init_func=init,
frames=200,
interval=1000,
blit=True)
FFMpegWriter = animation.writers['ffmpeg']
writer = animation.FFMpegWriter()
anim.save('polya.mp4', writer=writer)
line.set_data([], [])
return line, text
def animate(i):
text.set_text("T= " + f'{i:g}' + " K")
y = Spectral_Radiance(i)
line.set_data(x, y)
return line, text
#create animation
anim = FuncAnimation(fig,
animate,
init_func=anim_init,
frames=temperature_range,
interval=85,
blit=True)
ax.plot(x, Spectral_Radiance(wb/x), linestyle="dashed") #Wien curve
#format display
max_y = np.amax(Spectral_Radiance(max_temp))
text.set_x(max_x*0.75)
text.set_y(max_y*0.75)
ax.set_xlim(xmin=0, xmax=max_x)
ax.set_ylim(ymin=0, ymax=max_y*1.1)
ax.grid()
fig.tight_layout()
curva_param.append(ax[-1].plot(param_list[:, i], np.arange(len_params),
'r.-'))
ax[-1].set_xlabel('{:3.3f}'.format(param_list[-1, i]))
curva_datos = ax[0].plot(x_datos, y_datos, 'o', markersize=4, label='datos')
curva_modelo = ax[0].plot(x_datos, y_modelo, 'r-', label='modelo fiteado')
ax[0].set_xlabel("x")
ax[0].set_ylabel("y")
ax[0].legend(loc='best')
def actualizar(i):
etiqueta = 'paso {:>2d}'.format(i)
print(etiqueta)
curva_modelo[0].set_ydata(modelo(param_list[i], x_datos))
for j in range(num_params):
curva_param[j][0].set_ydata(np.arange(0, 1 + i))
curva_param[j][0].set_xdata(param_list[0:i + 1, j])
ax[1 + j].set_xlabel('{:3.3f}'.format(param_list[i, j]))
ax[0].set_title(etiqueta)
return [curva_modelo[0]] + [y[0] for y in curva_param] + ax
anim = FuncAnimation(fig,
actualizar,
frames=np.arange(len_params),
interval=250)
# anim.save('ajuste-least_squares.gif', dpi=80, writer='imagemagick')
def _generate_and_save_gif(self,
top_images,
bottom_images,
size_fig,
is_mask=False):
"""
Create figure with two images for sct_fmri_moco and sct_dmri_moco and save gif
:param top_images: list of images of mosaic before motion correction
:param bottom_images: list of images of mosaic after motion correction
:param size_fig: size of figure in inches
:param is_mask: display grid on top of mosaic
:return:
"""
if is_mask:
aspect = self.aspect_mask
else:
aspect = self.aspect_img
fig = Figure()
FigureCanvas(fig)
fig.set_size_inches(size_fig[0], size_fig[1], forward=True)
fig.subplots_adjust(left=0, top=0.9, bottom=0.1)
ax1 = fig.add_subplot(211)
null_image = np.zeros(np.shape(top_images[0]))
img1 = ax1.imshow(null_image, cmap='gray', aspect=float(aspect))
ax1.set_title('Before motion correction',
fontsize=8,
loc='left',
pad=2)
ax1.get_xaxis().set_visible(False)
ax1.get_yaxis().set_visible(False)
self._add_orientation_label(ax1)
if is_mask:
QcImage.grid(self, top_images[0], ax1)
ax2 = fig.add_subplot(212)
img2 = ax2.imshow(null_image, cmap='gray', aspect=float(aspect))
ax2.set_title('After motion correction', fontsize=8, loc='left', pad=2)
ax2.get_xaxis().set_visible(False)
ax2.get_yaxis().set_visible(False)
self._add_orientation_label(ax2)
if is_mask:
QcImage.grid(self, bottom_images[0], ax2)
ann = ax2.annotate('',
xy=(0, .025),
xycoords='figure fraction',
horizontalalignment='left',
verticalalignment='bottom',
fontsize=6)
def update_figure(i):
img1.set_data(top_images[i])
img1.set_clim(vmin=np.amin(top_images[i]),
vmax=np.amax(top_images[i]))
img2.set_data(bottom_images[i])
img2.set_clim(vmin=np.amin(bottom_images[i]),
vmax=np.amax(bottom_images[i]))
ann.set_text(f'Volume: {i + 1}/{len(top_images)}')
# FuncAnimation creates an animation by repeatedly calling the function update_figure for each frame
ani = FuncAnimation(fig, update_figure, frames=len(top_images))
if is_mask:
gif_out_path = self.qc_report.qc_params.abs_overlay_img_path()
else:
gif_out_path = self.qc_report.qc_params.abs_bkg_img_path()
if self._fps is None:
self._fps = 3
writer = PillowWriter(self._fps)
logger.info('Saving gif %s', gif_out_path)
ani.save(gif_out_path, writer=writer, dpi=self.qc_report.qc_params.dpi)
plt.scatter(data[apples][:, 0], data[apples][:, 1], color = "red", marker=".", label="Apples")
plt.scatter(data[pears][:, 0], data[pears][:, 1], color = "green", marker=".", label="Pears")
plt.xlabel("yellowness")
plt.ylabel("symmetry")
line, = plt.plot([], [], color="black", linewidth=2) # создаём линию, которая будет показывать границу разделения
from matplotlib.animation import FuncAnimation
perceptron_for_weights_line = create_perceptron(2) # создаём перцептрон нужной размерности со случайными весами
from functools import partial
weights_ani = partial(
step_by_step_weights, p=perceptron_for_weights_line, input_matrix=data[:, :-1], y=data[:, -1][:,np.newaxis]
) # про partial почитайте на https://docs.python.org/3/library/functools.html#functools.partial
ani = FuncAnimation(fig, func=plot_line, frames=weights_ani, blit=False, interval=10, repeat=True)
# если Jupyter не показывает вам анимацию - раскомментируйте строчку ниже и посмотрите видео
#ani.save("perceptron_seeking_for_solution.mp4", fps=15)
plt.show()
## Не забудьте остановить генерацию новых картинок, прежде чем идти дальше (кнопка "выключить" в правом верхнем углу графика)
# Он также подготовил несколько примеров, чтобы проиллюстрировать философию обучения перцептрона, которая не всегда интуитивна.
#
# Во-первых, количество неправильно классифицированных примеров не всегда уменьшается. То есть в процессе обучения у перцептрона могут случаться "взлёты и падения" - делился мудростью Зюк.
# In[71]:
def step_by_step_errors(p, input_matrix, y, max_steps=1e6):
delta_c = '{:.2e}'.format(np.max(SV_plt[-1,:]) - np.min(SV_plt[-1,:]))
cax.cla()
ticks = np.linspace(np.min(SV_plt), np.max(SV_plt),5)
cbar = fig.colorbar(cf, cax=cax, ticks=ticks, format='%.7f')
cbar.set_label(r'%s Density, $\rho$ [kg/m$^3$]' %plt_species)
if t_movie[i] < 1.0:
t_current = '{:.2e}'.format(t_movie[i])
else:
t_current = '{:.2f}'.format(t_movie[i])
ax.set_title('Time: ' + t_current + ' s\n'
r'$\Delta\rho_{max}$ outlet: ' + delta_c + r' kg/m$^3$')
fig.tight_layout(pad=wht_space)
anim = FuncAnimation(fig, animate, interval=500, frames=len(t_movie))
anim.save('animation.html')
# Move back to original cwd after files are saved:
os.chdir(cwd)
""" Comments and future steps """
"-----------------------------------------------------------------------------"
# Add species complexity so that model can be extended to work for Fuel Cell
# processes.
# Determine appropriate discretization in x-y space for grid independence.
print (start_point)
# plotpoints = groud_truth.ix[0,1:4].values
ax.scatter(*start_point, s=100, c='black', marker='v', label='origin')
# scat = ax.scatter([],[],[], c='r')
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('Z')
# colors = itertools.cycle(['r', 'y', 'b'])
def update(frame_number, groud_truth):
# global plotpoints, ax, scat
# plotpoints = [groud_truth.ix[:frame_number, 1].values, groud_truth.ix[:frame_number, 2].values, groud_truth.ix[:frame_number, 3].values]
# # print (plotpoints)
# # print ('-------------------- ')
# scat = ax.scatter(*plotpoints,c='r')
# return plotpoints, scat
# print (groud_truth.ix[frame_number, 1], groud_truth.ix[frame_number, 2], groud_truth.ix[frame_number, 3])
# print ('----------------------')
# scat.__offsets3d = (groud_truth.ix[frame_number, 1], groud_truth.ix[frame_number, 2], groud_truth.ix[frame_number, 3])
ax.scatter(groud_truth.ix[:frame_number, 1], groud_truth.ix[:frame_number, 2], groud_truth.ix[:frame_number, 3], c='r', s=1)
# The interval should be 50ms, because the camera is 20Hz.
if args.d == True:
animation = FuncAnimation(fig, update, fargs=(groud_truth,), interval=1)
else:
ax.scatter(groud_truth.ix[:, 1], groud_truth.ix[:, 2], groud_truth.ix[:, 3], c='red', alpha=0.1, s=1 )
plt.show()
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
fig, ax = plt.subplots()
xdata, ydata = [], []
ln, = ax.plot([], [], 'r-', animated=False)
def init():
ax.set_xlim(0, 100)
ax.set_ylim(0, 200)
return ln,
def update(frame):
# y = 2 * frame
xdata.append(frame)
ydata.append(2 * frame)
ln.set_data(xdata, ydata)
return ln,
ani = FuncAnimation(fig,
update,
frames=np.linspace(0, 100, 128),
init_func=init,
blit=True)
plt.show()
imgplot = ax.imshow(imgB, animated=True)
ax.axis('off')
## small delay for the visualiation of the beat itself
ani.event_source.interval = 40
elif ((frame % 4) == 3): # the frame 4
## Heart beat (small amplitude to mimick two-phase beating)
ax.clear()
imgplot = ax.imshow(imgC, animated=True)
ax.axis('off')
## small delay for the visualiation of the beat itself
ani.event_source.interval = 40
return imgplot, ln
### Animation
ani = FuncAnimation(fig,
update,
frames=dat.size * 4,
init_func=init,
blit=False,
repeat=False)
### Saving options (do not really work to keep the "real-time" of the animation
#ani.save(filename='anim.mp4')
# ani.save('anim.gif',writer='imagemagick')
# ani.to_html5_video()
### Show the animation
plt.show()
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation, FFMpegFileWriter
fig, ax = plt.subplots()
xdata, ydata = [], []
ln, = plt.plot([], [], 'b', animated=True)
f = np.linspace(-3, 9, 400)
def init():
ax.set_xlim(-3, 9)
ax.set_ylim(-0.25, 2)
ln.set_data(xdata, ydata)
return ln,
def update(frame):
xdata.append(frame)
ydata.append(np.exp(-frame**2))
ln.set_data(xdata, ydata)
return ln,
ani = FuncAnimation(fig,
update,
frames=f,
init_func=init,
blit=True,
interval=2.5,
repeat=False)
plt.show()
def simulate():
# Set up parameters for the simulation
xlim = 10 # The x-dimension goes from -xlim to xlim
n = 500 # The x-dimension is discretized in n parts
x = np.linspace(-xlim, xlim, n) # The x-dimension
dx = x[1] - x[0] # The size of a step in the x-dimension
dt = 0.05 # The timestep
m = 1 # The mass
hbar = 1 # The reduced Plank's constant
t0 = 0 # The initial time value
# The harmonic potential
k = 0.5
v = se_functions.harmonic_v(x, k)
# # The barrier potential
# potential = 0
# barrier = 50
# v = se_functions.square_v(x, barrier, 0.5, 0.01, potential)
# # The well potential
# potential = 0
# barrier = -10
# v = se_functions.square_v(x, barrier, 0.5, 0.01, potential)
# The wave packet for the harmonic potential
sigma = 0.5
x0 = -7
k0 = 0
psi0 = se_functions.gauss_wave_init(x, sigma, x0, k0)
# # The wave packet for barrier/well potentials
# sigma = 1
# x0 = -7
# k0 = 7
# psi0 = se_functions.gauss_wave_init(x, sigma, x0, k0)
# The Schrödinger equation to be solved
se = se_equations.SchrodingerEquation1D(x, v, dx, dt, psi0, m, hbar, t0)
# The solver used for the simulation
se_solver = se_solvers.SeSolver1DCN(se)
# The harmonic potential to be plotted
vplot = se.v / 30 - 0.7
# # The barrier potential to be plotted
# vplot = se.v / 50
# # The well potential to be plotted
# vplot = se.v / 10
# Set up the plot
rc('text', usetex=True)
fig = plt.figure()
ylim = np.max([np.max(se.prob()), np.max(np.abs(vplot))]) * 1.1
ax = fig.add_subplot(111, xlim=(-xlim, xlim), ylim=(-ylim, ylim))
potential_plot_data, = ax.plot(se.x, vplot, 'grey', label='$V(x)$')
probability_plot_data, = plt.plot([], [],
'xkcd:pastel orange',
label=r'$\Psi^* \Psi $')
psi_plot_data, = ax.plot([], [], 'xkcd:medium blue', label=r'$\Psi(x, t)$')
plt.legend(
handles=[potential_plot_data, probability_plot_data, psi_plot_data],
loc=1,
prop={'size': 20})
ax.set_xlabel("$x$", fontsize=24)
ax.set_ylabel(r"$\Psi$", fontsize=24)
ax.set_xticklabels([])
ax.set_yticklabels([])
plt.tight_layout()
plt.subplots_adjust(top=0.9)
def init():
psi_plot_data.set_data(se.x, se.psi)
probability_plot_data.set_data(se.x, se.prob())
return psi_plot_data, probability_plot_data
def update(frame):
se_solver.iterate()
psi_plot_data.set_data(se.x, se.psi)
probability_plot_data.set_data(se.x, se.prob())
return psi_plot_data, probability_plot_data
plt.show()
return FuncAnimation(fig, update, init_func=init, interval=1, blit=False)
def contar_kmeans(img):
data = np.reshape(img, (-1, 3))
data = np.float32(data)
criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 10, 1.0)
flags = cv2.KMEANS_RANDOM_CENTERS
compactness, labels, centers = cv2.kmeans(data, 1, None, criteria, 10,
flags)
return centers[0]
#Inicialização
captura = cv2.VideoCapture(0)
imagem = grab_frame(captura)
#Cria os dois subplots
ax1 = plt.subplot(1, 2, 1)
ax2 = plt.subplot(1, 2, 2)
#Cria duas imagens nos subplots
im1 = ax1.imshow(imagem)
im2 = ax2.imshow(retangulo(imagem))
#Animação e atualização
ani = FuncAnimation(plt.gcf(), atualizar, interval=200)
#Fechar
cid = plt.gcf().canvas.mpl_connect("key_press_event", close)
#Mostrar o gráfico
plt.show()
return points,
def animate(frame):
step()
points.set_data(x[:, 0], x[:, 1])
if frame is frames - 1:
plt.close()
return points,
totalTime = 10
frames = int(totalTime / dt)
anim = FuncAnimation(fig,
animate,
frames=range(frames),
init_func=init,
interval=dt * 1000)
plt.show()
"""
mport matplotlib.pyplot as plt
import numpy as np
import random
from matplotlib.animation import FuncAnimation
n = 4 # Number of particles
m = np.ones(n) # Particle masses
x = np.zeros((n,2)) # Particle positions (x and y for ith particle in x[i,0], x[i,1])
v = np.zeros((n,2)) # Particle velocities
f = np.zeros((n,2)) # Force accumulator
dt = 0.005 # Time step
ax.set_ylim(0, 1)
# animation effect function
def update(frame):
global pos, colors, csize
# transparency
colors[:, 3] = np.maximum(0, colors[:, 3] - 1.0 / n)
# increase the size when apply animation
csize += (size_max - size_min) / n
# frame rate
i = frame % 50
pos[i] = np.random.uniform(0, 1, 2)
csize[i] = size_min
colors[i, 3] = 1
# update scatter graph
scat_graph.set_edgecolor(colors)
scat_graph.set_sizes(csize)
scat_graph.set_offsets(pos)
return scat_graph
# creates animation effect (n frame per second)
animation = FuncAnimation(fig, update, interval=5)
plt.show()
def main(argv):
parser = argparse.ArgumentParser(
description="Plot the loss evolving through time")
parser.add_argument("metrics",
type=file_or_stdin,
help="The file containing the loss")
parser.add_argument("--to_file", help="Save the animation to a video file")
parser.add_argument("--step",
type=int,
default=1000,
help="Change that many datapoints in between frames")
parser.add_argument("--n_points",
type=int,
default=10000,
help="That many points in each frame")
parser.add_argument("--frames",
type=lambda x: slice(*map(maybe_int, x.split(":"))),
default=":",
help="Choose only those frames")
parser.add_argument("--lim",
type=lambda x: map(float, x.split(",")),
help="Define the limits of the axes")
parser.add_argument("--no_colorbar",
action="store_false",
dest="colorbar",
help="Do not display a colorbar")
args = parser.parse_args(argv)
loss = np.loadtxt(args.metrics)
fig, ax = plt.subplots()
lr = LinearRegression()
sc = ax.scatter(loss[:args.n_points, 0],
loss[:args.n_points, 1],
c=colors(loss[:args.n_points, 2]))
lims = args.lim if args.lim else [0, loss[:, 0].max()]
ln, = ax.plot(lims, lims, "--", color="black", label="linear fit")
ax.set_xlim(lims)
ax.set_ylim(lims)
ax.set_xlabel("$L(\cdot)$")
ax.set_ylabel("$\hat{L}(\cdot)$")
if args.colorbar:
mappable = ScalarMappable(cmap="viridis")
mappable.set_array(loss[:10000, 2])
plt.colorbar(mappable)
STEP = args.step
N_POINTS = args.n_points
def update(i):
s = i * STEP
e = s + N_POINTS
lr.fit(loss[s:e, :1], loss[s:e, 1].ravel())
ln.set_ydata([
lr.intercept_.ravel(),
lr.intercept_.ravel() + lims[1] * lr.coef_.ravel()
])
ax.set_title("Showing samples %d to %d" % (s, e))
sc.set_facecolor(colors(loss[s:e, 2]))
sc.set_offsets(loss[s:e, :2])
return ax, sc, ln
anim = FuncAnimation(fig,
update,
interval=100,
frames=np.arange(len(loss) / STEP)[args.frames],
blit=False,
repeat=False)
if args.to_file:
writer = animation_writers["ffmpeg"](fps=15)
anim.save(args.to_file, writer=writer)
else:
plt.show()
df_expanded = df_expanded.interpolate()
df_rank_expanded = df_rank_expanded.interpolate()
labels = df_expanded.columns
return df_expanded, df_rank_expanded, labels
if __name__ == '__main__':
# 处理mpl中文字体问题
mpl.rcParams["font.sans-serif"] = ["SimHei"]
mpl.rcParams["axes.unicode_minus"] = False
# 连接hive读数据并数据预处理
conn = hive.Connection(host='127.0.0.1', port=10000, auth='CUSTOM', username='******', password='******')
df = pd.read_sql(
sql="SELECT c_day,team_name,ten_days_buy_amt FROM data_market.ads_team_controlrates_monitor_so where c_day < '2020-08-24'",
con=conn)
data_res = df.set_index(['c_day', 'team_name']).unstack().fillna(0).head(11)
# 去除一级行索引
data_res1 = data_res.droplevel(level=0, axis=1)
# 挑选几只战队和适当时间比较
data_res1 = data_res1[['178战队', '698战队', 'Avenger战队', '众志战队', '传奇战队', '先锋战队', '光芒战队', '凌霄战队', '利刃战队', '北斗战队']]
data_res2 = data_res1.loc['2020-08-13':'2020-08-23']
# 平滑过渡
df_expanded, df_rank_expanded, labels = prepare_data(data_res2)
# 动画
fig = plt.Figure(figsize=(6, 3.5), dpi=144)
ax = fig.add_subplot()
anim = FuncAnimation(fig=fig, func=update, frames=len(df_expanded),
interval=200, repeat=False)
# 展示
html = anim.to_html5_video()
HTML(html)
def make_gif(data_to_plot,
frames=np.arange(10),
interval=120,
fig_sz=(8, 6),
dpi=100,
cmap='Greys',
mode='stim',
file_name=None,
save_dir='./gifs/'):
if not os.path.isdir(os.path.dirname(save_dir)):
os.makedirs(os.path.dirname(save_dir))
if file_name is None:
file_name = mode + '.gif'
if mode == 'stim':
# start the fig
fig, _ax = plt.subplots()
fig.set_size_inches(fig_sz)
# fig.set_tight_layout(True)
# find absmax for vmin/vmax and plot the first frame
_abs_max = np.max(abs(data_to_plot))
_plt = _ax.imshow(data_to_plot[0, ...],
cmap=cmap,
vmin=-_abs_max,
vmax=_abs_max)
fig.colorbar(_plt)
# start anim object
anim = FuncAnimation(fig,
_gif_update,
fargs=[_plt, _ax, data_to_plot, mode],
frames=frames,
interval=interval)
anim.save(save_dir + file_name, dpi=dpi, writer='imagemagick')
elif mode == 'subs':
width_y, width_x, nlags, ker_n = data_to_plot.shape
col_n = int(np.ceil(np.sqrt(ker_n)))
row_n = int(np.ceil(ker_n / col_n))
_plt_dict = {}
fig, axes = plt.subplots(row_n, col_n)
fig.set_size_inches((col_n * 2, row_n * 2))
_abs_max = np.max(abs(data_to_plot))
for ii in range(row_n):
for jj in range(col_n):
which_sub = ii * col_n + jj
if which_sub >= ker_n:
continue
axes[ii, jj].xaxis.set_ticks([])
axes[ii, jj].yaxis.set_ticks([])
tmp_plt = axes[ii, jj].imshow(data_to_plot[..., 0, which_sub],
cmap='Greys',
vmin=-_abs_max,
vmax=_abs_max)
_plt_dict.update({'ax_%s_%s' % (ii, jj): tmp_plt})
# start anim object
anim = FuncAnimation(fig,
_gif_update,
fargs=[fig, _plt_dict, data_to_plot, mode],
frames=np.arange(nlags),
interval=interval)
anim.save(save_dir + file_name, dpi=dpi, writer='imagemagick')
else:
raise ValueError, 'Not implemented yet.'
plt.close()
print('...your GIF is done! "%s" was saved at %s.' % (file_name, save_dir))
if not q.empty():
dataBlock = q.get_nowait()
index = 0
for data1 in dataBlock:
ydata[frame * 100 + index] = data1
index += 1
ln.set_data(xdata, ydata)
return ln,
try:
stream = sd.Stream(samplerate=FS,
channels=1,
blocksize=100,
callback=callback)
ani = FuncAnimation(fig,
update,
frames=40,
init_func=init,
interval=10,
blit=True)
mp.myPlotterStreamShow(fig, stream)
plt.show()
stream.start()
except Exception as e:
stream.stop()
print("Error")
import speedtest
import time
plt.style.use('fivethirtyeight')
plt.ylim((0,150))
st = speedtest.Speedtest()
timeList= []
speed = []
startTime = time.time()
index = count()
def animate(i):
plt.cla()
plt.ylim((0,150))
dls = st.download() /1000 /1000
curTime = time.time() - startTime
timeList.append(curTime)
speed.append(dls)
print(dls )
plt.plot(timeList,speed)
plt.legend(loc='upper left')
plt.xlabel("Time (sec)")
plt.ylabel("MB/s")
plt.tight_layout()
ani = FuncAnimation(plt.gcf(), animate, interval=10000)
plt.tight_layout()
plt.show()
def animate_pendulum_X(p, t, skip=1, see_plot=0):
#t = np.linspace(0, 10, 200)
#p = integrate_pendulum(n, t)
N_links = int(len(p[0])/4)
x, y = get_xy_coords(p, N_links)
fig, ax = plt.subplots(figsize=(6, 6))
fig.subplots_adjust(left=0, right=1, bottom=0, top=1)
ax.axis('off')
ax.set(xlim=(-1, 1), ylim=(-1, 1))
x=x[::skip]
y=y[::skip]
origin = np.zeros((len(x),1))
xlist=[]
ylist=[]
#draw lines from origin to first 2 nodes
xs=np.hstack([origin,x[:,0:1]])
xlist.append(xs)
xs=np.hstack([origin,x[:,1:2]])
xlist.append(xs)
xs=np.hstack([x[:,0:1],x[:,1:2]])
xlist.append(xs)
ys=np.hstack([origin,y[:,0:1]])
ylist.append(ys)
ys=np.hstack([origin,y[:,1:2]])
ylist.append(ys)
ys=np.hstack([y[:,0:1],y[:,1:2]])
ylist.append(ys)
for i in range(N_links-1):
xs=np.hstack([x[:,2*i+0:2*i+1],x[:,2*i+2:2*i+3]])
xlist.append(xs)
xs=np.hstack([x[:,2*i+2:2*i+3],x[:,2*i+3:2*i+4]])
xlist.append(xs)
xs=np.hstack([x[:,2*i+3:2*i+4],x[:,2*i+1:2*i+2]])
xlist.append(xs)
xs=np.hstack([x[:,2*i+0:2*i+1],x[:,2*i+3:2*i+4]])
xlist.append(xs)
xs=np.hstack([x[:,2*i+2:2*i+3],x[:,2*i+1:2*i+2]])
xlist.append(xs)
ys=np.hstack([y[:,2*i+0:2*i+1],y[:,2*i+2:2*i+3]])
ylist.append(ys)
ys=np.hstack([y[:,2*i+2:2*i+3],y[:,2*i+3:2*i+4]])
ylist.append(ys)
ys=np.hstack([y[:,2*i+3:2*i+4],y[:,2*i+1:2*i+2]])
ylist.append(ys)
ys=np.hstack([y[:,2*i+0:2*i+1],y[:,2*i+3:2*i+4]])
ylist.append(ys)
ys=np.hstack([y[:,2*i+2:2*i+3],y[:,2*i+1:2*i+2]])
ylist.append(ys)
total = 5*(N_links-1)+3
global xtemp
xtemp = xlist
global ytemp
ytemp =ylist
line, = ax.plot([], [], 'o-', lw=2)
lines = []
for index in range(total):
if index <3:
colors = "black"
else:
colors = "blue"
lobj = ax.plot([], [], 'o-', lw=2, color=colors)[0]
lines.append(lobj)
def init():
#line.set_data([], [])
for line in lines:
line.set_data([],[])
return lines
def animate(i):
"""
line.set_data(x[i], y[i]+2)
return line,
"""
#for index in range(0,1):
for lnum,line in enumerate(lines):
line.set_data(xlist[lnum][i], ylist[lnum][i]+1) # set data for each line separately.
return lines
anim = FuncAnimation(fig, animate, frames=len(t)/skip,
interval=1,
blit=True, init_func=init)
#1000/skip * t.max() / len(t)
if see_plot==0:
plt.close(fig)
return anim
grafic(list_time, acceleration, 'tempo s', ' aceleracao m/s^2')
grafic(position_x, list_v_x, 'posicao x (metro)', 'velocidade m/s')
grafic(position_z, list_v_z, 'posicao z (metro)', 'velocidade m/s')
#Animação do pêndulo
logical = input('Deseja abrir a simulação? Digite s ou n' '\n')
if logical == 's':
fig, ax = plt.subplots()
xdata, ydata = position_x, position_z
ln, = plt.plot([], [], 'ro', animated=True)
spring, = plt.plot([], [], 'b-', linewidth=2)
def init():
ax.set_xlim(-2 * L, 2 * L)
ax.set_ylim(2 * L, 0)
return ln,
def update(n):
spring.set_data([0.0, xdata[n]], [0.0, ydata[n]])
ln.set_data(xdata[n], ydata[n])
return spring, ln
ani = FuncAnimation(fig,
update,
n,
interval=0.001,
init_func=init,
blit=True)
plt.show()
for j in range(node_numbers):
if i != j and edge_list[i][j] > threshold:
G.add_edge(names[i],
names[j],
weight=edge_list[i][j] * 10,
color="red")
count += 1
edges = G.edges()
edges_weight_list = [G[u][v]['weight'] for u, v in edges]
edges_color_list = [G[u][v]['color'] for u, v in edges]
print("edge:", count)
# print(len(edges_color_list))
nx.draw_networkx_edges(G,
pos,
width=edges_weight_list,
arrowstyle="->",
edge_color=edges_color_list)
# limits = plt.axis('off') # turn of axis
plt.xlabel("Day: " + str(k + 1) + " to " + str(k + 61))
return G
anim = FuncAnimation(fig, animate, frames=T, repeat=False, interval=500)
plt.tight_layout()
anim.save('ani1.gif', dpi=300)
plt.show()
from picamera.array import PiRGBArray
from picamera import PiCamera
import time
import cv2
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
camera = PiCamera()
rawCapture = PiRGBArray(camera)
time.sleep(0.1)
def grab_frame():
camera.capture(rawCapture, format="bgr", use_video_port=True)
image = rawCapture.array
rawCapture.truncate(0)
return image
ax1 = plt.subplot(1, 2, 1)
im1 = ax1.imshow(grab_frame())
def update(i):
frame = grab_frame()
im1.set_data(frame)
return im1,
ani = FuncAnimation(plt.gcf(), update, interval=5, blit=True)
plt.show()
def __init__(self, window):
"""Initialize spectrogram canvas graphs."""
# Initialize variables to default values.
self.window = window
self.samples = 100 # Number of samples to store
self.fftSize = 256 # Initial FFT size just to render something in the charts
self.sampleRate = 0
self.binFreq = 0
self.binCount = self.fftSize / 2
self.graphUpdateHz = 10 # Update rate of the animation
self.coloredBin = None
self.magnitudes = np.zeros((self.samples, self.binCount))
# Tell numpy to ignore errors like taking the log of 0
np.seterr(all='ignore')
# Set up figure to hold plots
self.figure = Figure(figsize=(1024, 768),
dpi=72,
facecolor=(1, 1, 1),
edgecolor=(0, 0, 0))
# Set up 4x4 grid to hold 2 plots and colorbar
gs = GridSpec(2, 2, height_ratios=[1, 2], width_ratios=[9.5, 0.5])
gs.update(left=0.075, right=0.925, bottom=0.05, top=0.95, wspace=0.05)
# Set up frequency histogram bar plot
self.histAx = self.figure.add_subplot(gs[0])
self.histAx.set_title('Frequency Histogram')
self.histAx.set_ylabel('Intensity (decibels)')
self.histAx.set_xlabel('Frequency Bin (hz)')
self.histAx.set_xticks([])
self.histPlot = self.histAx.bar(np.arange(self.binCount),
np.zeros(self.binCount),
width=1.0,
linewidth=0.0,
facecolor='blue')
# Set up spectrogram waterfall plot
self.spectAx = self.figure.add_subplot(gs[2])
self.spectAx.set_title('Spectrogram')
self.spectAx.set_ylabel('Sample Age (seconds)')
self.spectAx.set_xlabel('Frequency Bin (hz)')
self.spectAx.set_xticks([])
self.spectPlot = self.spectAx.imshow(self.magnitudes,
aspect='auto',
cmap=get_cmap('jet'))
# Add formatter to translate position to age in seconds
self.spectAx.yaxis.set_major_formatter(
FuncFormatter(lambda x, pos: '%d' % (x *
(1.0 / self.graphUpdateHz))))
# Set up spectrogram color bar
cbAx = self.figure.add_subplot(gs[3])
self.figure.colorbar(
self.spectPlot,
cax=cbAx,
use_gridspec=True,
format=FuncFormatter(lambda x, pos: '%d' % (x * 100.0)))
cbAx.set_ylabel('Intensity (decibels)')
# Initialize canvas
super(SpectrogramCanvas, self).__init__(self.figure)
# Hook up mouse and animation events
self.mpl_connect('motion_notify_event', self._mouseMove)
self.ani = FuncAnimation(self.figure,
self._update,
interval=1000.0 / self.graphUpdateHz,
blit=False)
def extract_current_folder():
'''
Extracts all photometry in the current folder, and animates one of the result sources
Only treats fits file starting with hst and finishing with .fits
'''
global windows, xvv, yvv
print('Extracting sources at positions : ', src_list)
print('Filename\tEpoch\tMagnitudes')
filenames = os.listdir('.')
filenames.sort()
mags = []
times = []
for f in filenames:
if not f.startswith('hst') or not f.endswith('.fits'):
continue
# Extracting time and magnitude from current file
time, mag = extract_photometry(f)
times.append(time)
mags.append(mag)
mags = np.asarray(mags)
times = np.asarray(times)
# Plotting the magnitudes 1 by 1 to remove the NaNs
for sid, _ in enumerate(src_list):
# Sorting the files and magnitudes in Epoch order in case the files are
# not already sorted
mask = ~np.isnan(mags[:, sid])
cur_mags = mags[mask, sid]
cur_times = times[mask]
N = cur_mags.shape[0]
sorted_ids = [i for i in range(N)]
sorted_ids.sort(key=lambda x: cur_times[x])
cur_mags = cur_mags[sorted_ids]
cur_times = cur_times[sorted_ids]
plt.plot(cur_times, cur_mags, '-+')
plt.show()
# Animation part ... A bit ugly
if wid > -1:
# Ordering times
N = len(windows)
sorted_ids = [i for i in range(N)]
sorted_ids.sort(key=lambda x: times[x])
# 3D matrix : dim 0 -> Time, dim 1 -> y, dim 2 -> x
windows = np.asarray(windows)[sorted_ids, :, :]
max_v = windows.max()
min_v = windows.min()
z = windows[0]
# Building figure
fig = plt.figure(figsize=(10, 10))
ax = fig.add_subplot(111, projection='3d')
p = ax.plot_surface(xvv, yvv, z)
# Number of interpolation points
inter_t = 60
inter_x = 100
inter_y = 100
ox = xvv[0, :]
oy = yvv[:, 0]
ot = times[sorted_ids]
# Generating vector coords and meshgrid
tv = np.linspace(ot.min(), ot.max(), inter_t)
xv = np.linspace(xvv.min(), xvv.max(), inter_x)
yv = np.linspace(yvv.min(), yvv.max(), inter_y)
MT, MX, MY = np.meshgrid(tv, xv, yv, indexing='ij')
# Rolling back to 1D for interpolation
MT = MT.ravel()
MX = MX.ravel()
MY = MY.ravel()
# Interpolation
pos = np.stack((MT, MX, MY)).T
f = RegularGridInterpolator((ot, ox, oy), windows)
w_array = f(pos)
w_array = w_array.reshape((inter_t, inter_x, inter_y))
# Rebuilding 2D position matrices
MX, MY = np.meshgrid(xv, yv)
# Update function for matplotlib's anim
def update(i):
print('Rendering frame {}/{}'.format(i + 1, inter_t))
z = w_array[i]
ax.clear()
p = ax.plot_surface(MX, MY, z)
ax.set_zlim(min_v, max_v)
return p,
def init():
update(0)
# And rendering
ani = FuncAnimation(fig,
update,
init_func=init,
frames=range(1, inter_t))
Writer = animation.writers['ffmpeg']
w = Writer(fps=15, bitrate=1800)
print('Saving animation')
ani.save('pulse.mp4', writer=w)
plt.close('all')
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
fig, ax = plt.subplots()
xdata, ydata = [], []
ln, = plt.plot([], [], 'ro', animated=True)
def init():
ax.set_xlim(-1.5, 1.5)
ax.set_ylim(-1.5, 1.5)
return ln,
def update(frame):
xdata.append(np.cos(frame))
ydata.append(np.sin(frame))
ln.set_data(xdata, ydata)
return ln,
ani = FuncAnimation(fig,
update,
frames=np.linspace(0, 2 * np.pi, 50),
init_func=init,
blit=True)
ax.set_aspect(1. / ax.get_data_ratio())
plt.show()
def animateTSP(country, history, points):
"""
:param country: string
:param history: list[int, float, float]
:param points: list[int, float, float]
:return:
"""
try:
# Prepare the coordinates for plotting the trip
cityName = []
latitude = []
longitude = []
for city in points:
cityName.append(city[0])
latitude.append(city[1] / 1000.)
longitude.append(city[2] / 1000.)
cityName.append(cityName[0])
latitude.append(latitude[0])
longitude.append(longitude[0])
plt.figure(figsize=(7, 7))
# Specify tripMap width and height
if country == "Djibouti":
tripMap = Basemap(width=350000,
height=270000,
resolution='i',
projection='tmerc',
lat_0=11.572076,
lon_0=43.145645)
else:
tripMap = Basemap(width=250000,
height=250000,
resolution='i',
projection='tmerc',
lat_0=25.286106,
lon_0=51.534817)
tripMap.drawmapboundary(fill_color='aqua')
tripMap.fillcontinents(color='#FFE4B5', lake_color='aqua')
tripMap.drawcoastlines()
tripMap.drawcountries()
# Range the frames
_frames = len(history) // 1500
_frameRange = range(0, len(history), _frames)
# Path is represented as line
line = tripMap.plot([], [], 'D-', markersize=3, linewidth=1,
color='r')[0]
# initial function
def init_func():
# Draw node dots on graph
x = [longitude[i] for i in history[0]]
y = [latitude[i] for i in history[0]]
x, y = tripMap(x, y)
tripMap.plot(x, y, 'bo', markersize=3)
# Empty initialization
line.set_data([], [])
return line,
# animate function
def gen_function(frame):
# Update the graph for each frame
x = [longitude[i] for i in history[frame] + [history[frame][0]]]
y = [latitude[i] for i in history[frame] + [history[frame][0]]]
x, y = tripMap(x, y)
line.set_data(x, y)
return line
# Animate the graph
_animation = FuncAnimation(plt.gcf(),
func=gen_function,
frames=_frameRange,
init_func=init_func,
interval=10,
repeat=False)
plt.show()
except:
EH()
ymain.append(y1)
yintegral.append(y2)
ydiff.append(y3)
line_main.set_data(xdata, ymain)
line_integral.set_data(xdata, yintegral)
line_diff.set_data(xdata, ydiff)
return [line_main, line_integral, line_diff]
# Можно изменить figsize, если не вмещается окошко. lw - толщина линии
fig, ax = plt.subplots(3, 1, figsize=(7, 10))
line_main, = ax[0].plot([], [], 'b', lw=1.5)
line_integral, = ax[1].plot([], [], 'r', lw=1.5)
line_diff, = ax[2].plot([], [], 'g', lw=1.5)
ax[0].grid()
ax[1].grid()
ax[2].grid()
# Название графиков
ax[0].set_title('Main function')
ax[1].set_title('Integration')
ax[2].set_title('Differentiation')
xdata, ymain, yintegral, ydiff = [], [], [], []
# Установить номер COM-порта и скорость
ser = serial.Serial('COM3', 115200)
# interval - период опроса COM порта в миллисекундах
ani = FuncAnimation(fig, run, interval=10, init_func=init)
plt.show()