def make_frame_mpl(t):
global thresh, ax0, ax1
i = int(t)
if i < thresh:
line.set_data(x[0:i], y[tStart:tStart + i])
patch.set_data(x[0:i], z[tStart:tStart + i])
#ax1.fill_between(x[i-1:i], 0, z[i-1:i],color="blue",alpha=0.5);
# for X, p in zip(x[0:i],patch) :
# if X == 1:
# p.set_height(1);
last_frame = mplfig_to_npimage(fig)
return last_frame
else:
delta = i - thresh
ax0.set_xlim(tStart + delta, tStart + i)
ax1.set_xlim(tStart + delta, tStart + i)
line.set_data(x[delta:i], y[tStart + delta:tStart + i])
patch.set_data(x[delta:i], z[tStart + delta:tStart + i])
#ax1.fill_between(x[i-1:i], 0, z[i-1:i],color="blue",alpha=0.5);
# for X, p in zip(x[delta:i],patch) :
# if X == 1:
# p.set_height(1);
last_frame = mplfig_to_npimage(fig)
return last_frame
def make_frame_mpl(t):
i = int(t)
if i < kwargs["video_photometry"]["display_threshold"]*kwargs["video_photometry"]["plot_acceleration"]:
try:
behavior_plot.set_data(x_data[0:i], y_data[0][0:i])
df_plot.set_data(x_data[0:i], y_data[1][0:i])
except :
print("Oups a problem occured")
last_frame = mplfig_to_npimage(live_figure)
return last_frame
else:
delta = (i/kwargs["video_photometry"]["plot_acceleration"]) - kwargs["video_photometry"]["display_threshold"]
live_ax0.set_xlim(x_data[0]+delta, x_data[0]+(i/kwargs["video_photometry"]["plot_acceleration"]))
live_ax1.set_xlim(x_data[0]+delta, x_data[0]+(i/kwargs["video_photometry"]["plot_acceleration"]))
try:
behavior_plot.set_data(x_data[0:i], y_data[0][0:i])
df_plot.set_data(x_data[0:i], y_data[1][0:i])
except:
print("Oups a problem occured")
last_frame = mplfig_to_npimage(live_figure)
return last_frame
def make_frame_mpl(t):
i = int(t)
if i < thresh*plotAcceleration:
try:
cotton_graph.set_data(x[0:i], yData[0][0:i])
# cotton_graph.fill_between(x[0:i], 0, y0[0:i], color="blue", alpha=0.8)
# eventGraph.set_data(x[0:i], y1)
# calciumGraph.set_data(x[0:i], y2[0:i])
df_graph.set_data(x[0:i], yData[3][0:i])
except:
print("Oups a problem occured")
last_frame = mplfig_to_npimage(live_fig)
return last_frame
else:
delta = (i/plotAcceleration) - thresh
liveAx0.set_xlim(x[0]+delta, x[0]+(i/plotAcceleration))
# liveAx1.set_xlim(x[0]+delta, x[0]+(i/plotAcceleration))
# liveAx2.set_xlim(x[0]+delta, x[0]+(i/plotAcceleration))
live_ax3.set_xlim(x[0]+delta, x[0]+(i/plotAcceleration))
try:
cotton_graph.set_data(x[0:i], yData[0][0:i])
# cotton_graph.fill_between(x[0:i], 0, y0[0:i], color="blue", alpha=0.8)
# eventGraph.set_data(x[0:i], y1[0:i])
# calciumGraph.set_data(x[0:i], y2[0:i])
df_graph.set_data(x[0:i], yData[3][0:i])
except:
print("Oups a problem occured")
last_frame = mplfig_to_npimage(live_fig)
return last_frame
def displayBarChart():
plt.cla()
h, w, _ = frame.shape
index = np.arange(3)
labels = df_Classes['ClassAr']
# display only to 3
PredClasses = model.predict(img64Array).reshape(32)
tempTop3Index = np.argpartition(-PredClasses, 3)
Top3Index = tempTop3Index[:3]
tempTop3Values = np.partition(-PredClasses, 3)
Top3Values = -tempTop3Values[:3]
for lbl in labels:
lbl = get_display(arabic_reshaper.reshape(lbl))
# fig, ax = plt.subplots(figsize=(3, 2), facecolor='w')
ax.bar(index, Top3Values)
ax.set_ylabel('Score')
ax.set_title('Prediction Prop')
ax.set_xticks(index)
ax.set_xticklabels(labels)
plt.tight_layout()
graphRGB = mplfig_to_npimage(fig)
gh, gw, _ = graphRGB.shape
# frame[:gh, w - gw:, :] = mplfig_to_npimage(fig)
return mplfig_to_npimage(fig)
def _make_path_frame(self, t):
self._timeData.append(t)
try:
pathTile = self._pathIterator.__next__()
except StopIteration:
return mplfig_to_npimage(self._vfig)
self._frameupdate(pathTile, self._PATH_TILE)
return mplfig_to_npimage(self._vfig)
def make_frame_for_heatmap(t, maps, cmap, fps, fig, ax, global_vmax):
ind = np.floor(t*fps).astype(np.int)
if ind>=len(maps):
return bindings.mplfig_to_npimage(fig)
local_vmax = maps[ind].max()
ax.clear()
ax.imshow(maps[ind], cmap=cmap, vmax=max(local_vmax, 0.5*global_vmax))
ax.axis('off')
return bindings.mplfig_to_npimage(fig)
def make_frame(t):
i = min(int(np.round(t / meshsize)), len(r_history) - 1)
ax = axs[0]
ax.clear()
color = "blue"
x_ticks = np.arange(1, len(conv) + 1)
ax.set_ylim([0, 1])
ax.set_xlim([0, len(conv)])
ax.plot(x_ticks[:(i + 1)], conv[:(i + 1)], "o",
color=color) # , label=r"{} $\mu = {:.2f}, i = {}$".format(title, factor, num_sweeps))
if i >= num_sweeps:
ax.scatter([num_sweeps], [conv[num_sweeps - 1]], 120, facecolors='none', edgecolors=color)
ax.set_ylabel("Residual Reduction Factor")
ax.set_xlabel("Sweep #")
ax.grid(True)
ax = axs[1]
ax.clear()
ax.plot(x_history[i][:, 0])
x_init = x_history[0][:, 0]
ax.set_ylim([min(x_init) - 0.01, max(x_init) + 0.01])
ax.set_title("Error after {} sweeps".format(i))
ax = axs[2]
ax.clear()
ax.plot(r_history[i][:, 0])
r_init = r_history[0][:, 0]
ax.set_ylim([min(r_init) - 0.01, max(r_init) + 0.01])
ax.set_title("Residual after {} sweeps".format(i))
return mplfig_to_npimage(fig)
def make_frame(t):
top_nucleotide_index = t * graphic_record.sequence_length / duration
graphic_record.top_position = top_nucleotide_index
ax, _ = graphic_record.plot(figure_width=8)
np_image = mplfig_to_npimage(ax.figure)
plt.close(ax.figure)
return np_image
def make_frame(t):
"""Return an image of the frame for time t"""
fig = plt.gcf()
ax = plt.gca()
f_idx = int(t * fps)
start = hop * f_idx
end = start + window
to_plot = pianoroll[start:end].T / 128.
extent = (start, end - 1, 0, 127)
ax.imshow(to_plot, cmap=cmap, aspect='auto', vmin=0, vmax=1,
origin='lower', interpolation='none', extent=extent)
if xtick == 'beat':
next_major_idx = beat_resolution - start % beat_resolution
if start % beat_resolution < beat_resolution//2:
next_minor_idx = beat_resolution//2 - start % beat_resolution
else:
next_minor_idx = (beat_resolution//2 - start % beat_resolution
+ beat_resolution)
xticks_major = np.arange(next_major_idx, window, beat_resolution)
xticks_minor = np.arange(next_minor_idx, window, beat_resolution)
if end % beat_resolution < beat_resolution//2:
last_minor_idx = beat_resolution//2 - end % beat_resolution
else:
last_minor_idx = (beat_resolution//2 - end % beat_resolution
+ beat_resolution)
xtick_labels = np.arange((start + next_minor_idx)//beat_resolution,
(end + last_minor_idx)//beat_resolution)
ax.set_xticks(xticks_major)
ax.set_xticklabels('')
ax.set_xticks(xticks_minor, minor=True)
ax.set_xticklabels(xtick_labels, minor=True)
ax.tick_params(axis='x', which='minor', width=0)
return mplfig_to_npimage(fig)
def make_frame(t):
axes.clear()
#wind=np.array([0.1,0.1])
wind=np.zeros(2)
saving=np.zeros((N,2))
# ------------------------UPDATING ACCELERATION---------------------------------------
for i in range(N):
aux=cohesion(state,N,i)
#aux=np.zeros(2)
aux2=exclusion(state,N,i)
#aux2=np.zeros(2)
aux3=aligment(state,N,i)
#aux3=np.zeros(2)
saving[i][0]=aux[0]+aux2[0]+aux3[0]+0.0*random()
saving[i][1]=aux[1]+aux2[1]+aux3[1]+0.0*random()
#UPDATING
for i in range(N):
state[i][5]=saving[i][0]
state[i][6]=saving[i][1]
#---------------------------------------------------------------------------------
#Updating VELOCITIES
for i in range(N):
aux=updating_velocity(state,N,i)
state[i][3]=aux[0]+wind[0]
state[i][4]=aux[1]+wind[1]
aux4=cruise_v(state,i)
state[i][3]=state[i][3]+aux4[0]
state[i][4]=state[i][4]+aux4[1]
#Updating positions
for i in range(N):
aux=updating_position(state,N,i)
state[i][1]=aux[0]
if ((state[i][1] >= float(L)) or (state[i][1] <= float(-L))): #BOUNDARY CONDITIONS
state[i][3]=-state[i][3]
state[i][1]=state[i][1]+2.0*state[i][3]
state[i][2]=aux[1]
if ((state[i][2] >= float(L)) or (state[i][2] <= float(-L))):
state[i][4]=-state[i][4]
state[i][2]=state[i][2]+2.0*state[i][4]
#SAVE DATE ON FILE
#if controls==True:
#data=pd.DataFrame(state,columns="#N x1 x2 v1 v2".split())
#data.to_csv('data.dat', header=True, index=False, sep='\t', mode='a')
#CREATE ARROWS
for i in range (N):
pass
speed=sqrt(state[i][3]**2+state[i][4]**2)
plt.arrow(state[i][1],state[i][2],state[i][3]/speed,state[i][4]/speed,head_width=10)
axes.axes.get_xaxis().set_ticks([]) #ERASE XTICS ON X_AXE
axes.axes.get_yaxis().set_ticks([])
#fig.savefig("filename.png", dpi=200) # plot canvas
#plt.show()
return mplfig_to_npimage(fig)
def make_frame_mpl(t):
ax.clear()
t = int(t * FPS) + 1
one_sec_loc = loc[(t - FPS):(t + 1)].reshape(
-1, 10, 2) if t > FPS else loc[:t].reshape(-1, 10, 2)
draw(G, one_sec_loc)
return mplfig_to_npimage(fig_mpl) # 图形的RGB图像
def make_frame_mpl(t):
frame = int(round(t * fps))
imshow_heatmaps.set_data(absMotions[frame])
return mplfig_to_npimage(
savefig_heatmaps) # RGB image of the figure
def draw_frame_x(df, t, fps, voronoi=False):
fig, ax, dfFrame = footyviz.draw_frame(df, t=t, fps=fps)
if voronoi:
fig, ax, dfFrame = footyviz.add_voronoi_to_fig(fig, ax, dfFrame)
image = mplfig_to_npimage(fig)
plt.close()
return image
def make_frame(t):
ax.clear()
ax.axis('off')
ax.set_title(title, fontsize=16)
self.step()
ax.imshow(into_array(bset), cmap=cmap, animated=True)
return (mplfig_to_npimage(fig))
def make_frame_mpl_for_map_points(t):
i = int(t * 40)
n = 1. / (pdist(X_iter[..., i], 'sqeuclidean') + 1)
Q = n / (2.0 * np.sum(n))
Q = squareform(Q)
im.set_data(Q)
return mplfig_to_npimage(f)
def make_frame(t):
index_max = int((1.0 * t / 1000) * number_of_points)
line.set_xdata(jupiter_traj[:index_max, 0])
line.set_ydata(jupiter_traj[:index_max, 1])
line.set_zdata(jupiter_traj[:index_max, 2])
return mplfig_to_npimage(fig)
def animate(t):
# Access our initialized variables from outside the function
global last_t
global tempgraph
# Round time to nearest 0.5 second. This limits the number of times we
# update the graph. Each graph update costs 10-20 seconds to draw, so by
# limiting this, we can render the graph an order of magnitude faster
temp_t = np.round(t * 2) / 2.0
# Only update the graph if we are at the next 0.5 seconds
if t > 0 and temp_t != last_t:
# Update our timekeeping variable
last_t = temp_t
# Delete the previous graph, otherwise we will keep plotting over
# the same graphs again and again
for coll in (ax.collections):
ax.collections.remove(coll)
# Load only the played portion of the mp3 and plot them
y2, sr2 = librosa.load('extracted_audio.mp3',
mono=False,
duration=t)
waveplot(y2, sr=sr2, color='b', alpha=0.8)
waveplot(y, sr=sr, color='b', alpha=0.25)
# Update the output graph
tempgraph = mplfig_to_npimage(fig)
return tempgraph
def update(frame_number):
# print frame_number
x, y = gen.next()
f.set_pos(xx + x, yy + y)
# f.set_pos(frame_number,100)
src = f.next()
img.set_array(src)
a, z = ld.get_value(copy(src))
# print x,y, z
img2.set_array(a)
# print z, x, y
xs.append(xx + x)
ys.append(yy + y)
line.set_data(xs, ys)
scatter2.set_data([xx + x], [yy + y])
ts.append(time.time() - st)
# print z
z /= 3716625.0
z += 0.1 * random.random()
pattern.set_point(z, x, y)
zs.append(z)
# print zs
tvint.set_data(ts, zs)
tcs.append(f.time_constant)
rcs.append(f.cradius)
tc.set_data(ts, tcs)
rs.set_data(ts, rcs)
return mplfig_to_npimage(fig)
def make_frame(t):
ax.clear()
ax.axis('off')
ax.set_title(title, fontsize=16)
self.step()
self.plot(ax, cmap)
return (mplfig_to_npimage(fig))
def update(t):
global dt,ddt,v,prob,x0,y0,n
prova = t/(8.0*dt) + ddt #every 4 time steps, ddt is a small increment for the int to work properly
Npart = 1 + int((prova))
x = np.empty([Npart]) #x-positions of the particles
y = np.empty([Npart]) #y-positions of the particles
for j in range(0,Npart):
x[j] = x0[j]
y[j] = y0[j]
if n[j]==0: #if it's the first time that changes
if x[j]>=-1.1 and x[j]<-0.5: #if it's close to 0
randnumber=np.random.random(size=None) #gives us a random number
if randnumber<=prob:
x0[j] = x0[j] + float(v*dt) #keeps going to the right
y0[j] = y0[j] - float(v*dt) #keeps going onwards (y=0)
n[j]=1 #n=1 means that it passed
else:
x0[j] = x0[j] - float(v*dt) #goes to the left
y0[j] = y0[j] - float(v*dt) #goes down
n[j]=2 #n=2 means particle going backwards
else: #still not in the separating region
x0[j] = x0[j] + float(v*dt) #keeps going to the right
y0[j] = y0[j] - float(v*dt) #keeps going onwards (y=0)
else:
if n[j]==1:
x0[j] = x0[j] + float(v*dt)
y0[j] = y0[j] - float(v*dt)
elif n[j]==2:
x0[j] = x0[j] - float(v*dt) #goes to the left
y0[j] = y0[j] - float(v*dt) #goes down
line.set_xdata(x)
line.set_ydata(y)
line2.set_xdata(x)
line2.set_ydata(y)
return mplfig_to_npimage(fig_mpl)
def frame(n, state):
fig = plt.figure()
cm = plt.get_cmap('gist_rainbow')
col = {i + 1: cm(1. * i / n) for i in range(n)}
h = n / 2 + 0.5
plt.xlim(0, 6)
plt.ylim(0, h + 1.5)
x_lab = {'a': 1, 'b': 3, 'c': 5}
plt.xticks(())
plt.yticks(())
eps = 0.6 / (n - 1)
axis = plt.gca()
for key in state:
l = x_lab[key]
values = copy.deepcopy(state[key])
plt.plot([l, l], [0.5 * len(values) + 0.07, h],
color='0.25',
linewidth=5.0)
k = -1
while len(values) > 0:
k += 1
i = max(values)
values.remove(i)
axis.add_patch(
Rectangle((l - 0.8 + (n - i) * eps, k * 0.5),
(1 - 0.2 - (n - i) * eps) * 2,
0.5,
facecolor=col[i],
alpha=1))
return mplfig_to_npimage(fig)
def voxel(vox, color=None, f_name=None, npimage=False, view=(30, 45)):
assert (vox.ndim == 3)
vox = vox.transpose(2, 0, 1)
color = color.transpose(2, 0, 1)
if color is None or len(np.unique(color)) <= 2:
color = 'red'
else:
color_map = plt.get_cmap('coolwarm')
color = color_map(color)
fig = plt.figure()
ax = fig.gca(projection='3d')
#ax.voxels(vox, facecolors=color, edgecolor='k')
ax.voxels(vox, edgecolor='k')
ax.view_init(view[0], view[1])
if npimage:
return mplfig_to_npimage(fig)
if f_name is not None:
params = utils.read_params()
f_name = os.path.join(params["DIRS"]["OUTPUT"], f_name)
utils.make_prev_dirs(f_name)
fig.savefig(f_name, bbox_inches='tight', dpi=2400)
fig.clf()
plt.close()
return
return fig.show()
def update(frame_number):
# print frame_number
x, y = gen.next()
f.set_pos(xx + x, yy + y)
# f.set_pos(frame_number,100)
src = f.next()
img.set_array(src)
a, z = ld.get_value(copy(src))
# print x,y, z
img2.set_array(a)
# print z, x, y
xs.append(xx + x)
ys.append(yy + y)
line.set_data(xs, ys)
scatter2.set_data([xx + x], [yy + y])
ts.append(time.time() - st)
# print z
z /= 3716625.0
z += 0.1 * random.random()
pattern.set_point(z, x, y)
zs.append(z)
# print zs
tvint.set_data(ts, zs)
tcs.append(f.time_constant)
rcs.append(f.cradius)
tc.set_data(ts, tcs)
rs.set_data(ts, rcs)
return mplfig_to_npimage(fig)
def get_frame(i):
i = int(i * fps)
plt.clf()
ax = fig.add_subplot(111, projection='3d')
ax.set_xlim(-mx, mx)
ax.set_ylim(-mx, mx)
ax.set_zlim(-mx, mx)
if (t[-1] < 1.0):
plt.title('t = ' + str(t[i]) + ' s', fontsize=36)
else:
plt.title('t = ' + time.strftime('%H:%M:%S', time.gmtime(t[i])),
fontsize=36)
RR = np.reshape(R[i], (3, 3), order='F')
points = P.dot(np.dot(Q, (RR.T))) + x[i]
ax.add_collection3d(
mplot3d.art3d.Poly3DCollection(points,
facecolor=[0.5, 0.5, 0.5],
lw=0.5,
edgecolor=[0, 0, 0],
alpha=0.66))
plt.setp(ax.get_xticklabels(), visible=False)
plt.setp(ax.get_yticklabels(), visible=False)
plt.setp(ax.get_zticklabels(), visible=False)
return mplfig_to_npimage(fig)
def draw_frame_x(hometeam,awayteam, t, figax=None, fps=25,
team_colors=('r','b'), field_dimen = (106.0,68.0),
include_player_velocities=False, PlayerMarkerSize=10, PlayerAlpha=0.7,dpi=100):
""" draw_frame_x(hometeam,awayteam, t)
Generates an image of the frame t*fps compatible with moviepy
Parameters
-----------
hometeam: home team tracking data DataFrame. Movie will be created from all rows in the DataFrame
awayteam: away team tracking data DataFrame. The indices *must* match those of the hometeam DataFrame
t: time of the frame
fig,ax: Can be used to pass in the (fig,ax) objects of a previously generated pitch. Set to (fig,ax) to use an existing figure, or None (the default) to generate a new pitch plot,
frames_per_second: frames per second to assume when generating the movie. Default is 25.
team_colors: Tuple containing the team colors of the home & away team. Default is 'r' (red, home team) and 'b' (blue away team)
field_dimen: tuple containing the length and width of the pitch in meters. Default is (106,68)
include_player_velocities: Boolean variable that determines whether player velocities are also plotted (as quivers). Default is False
PlayerMarkerSize: size of the individual player marlers. Default is 10
PlayerAlpha: alpha (transparency) of player markers. Defaault is 0.7
Returns
-----------
a numpy image compatible with moviepy.VideoClip
"""
#we have to convert t*fps to int because t is a float
fig,ax=plot_frame(hometeam.iloc[int(t*fps)], awayteam.iloc[int(t*fps)], figax=figax,
team_colors=team_colors, field_dimen = field_dimen,
include_player_velocities=include_player_velocities, PlayerMarkerSize=PlayerMarkerSize, PlayerAlpha=PlayerAlpha)
image = mplfig_to_npimage(fig)
plt.close()
return image
def animate(t):
myIndex = int(t*myFPS)
myCLOBFrameInfo = myCLOBFrameInfos[myIndex]
myFrameEndTime = myCLOBFrameInfo.endTime
myFBAFrameInfo = myFBAFrameInfos[myIndex]
# myFBAFrameInfo = next(i for i in myFBAFrameInfos[::-1] if i.endTime <= myFrameEndTime)
myTimeStamp = myCLOBFrameInfo.endTime
drawTradeInfoOnAxis(plt, ax0, myFrameEndTime, myCLOBFrameInfo, myCLOBFrameInfos, myTimeBucketDiff, myCLOBBidBar, myCLOBOfferBar, myFBAMatchBar,
myPriceMin, myPriceMax, myAxisAlpha, True, myFBAInterval) # put in fba match bar in there
drawTradeInfoOnAxis(plt, ax1, myFrameEndTime, myFBAFrameInfo, myFBAFrameInfos, myTimeBucketDiff, myFBABidBar, myFBAOfferBar, myFBAMatchBar,
myPriceMin, myPriceMax, myAxisAlpha, False, myFBAInterval)
global myFBALastEndTime
global myIsMatched
global myTradeTime
global myMatchPrice
global myMatchSize
global myFBATrades
myBidTracker.set_xdata([myTimeStamps[myIndex]])
myBidTracker.set_ydata([myBids[myIndex]])
myOfferTracker.set_xdata([myTimeStamps[myIndex]])
myOfferTracker.set_ydata([myOffers[myIndex]])
for myTrade in myCLOBFrameInfo.trades:
ax2.plot(myTimeStamps[myIndex], myTrade.price, color = myTradeColor, marker = 'x', alpha = .4, markersize = myTrade.tradeVolume/10)
ax2.plot(myTimeStamps[myIndex], myTrade.price, color = myTradeColor, marker = '.', alpha = .4, markersize = myTrade.tradeVolume/20)
fig.canvas.draw()
ax2.set_title(myTimeStamp.strftime("%d/%m/%y %H:%M:%S"), color="white", alpha = .35)
return(mplfig_to_npimage(fig))
def get_fig_by_frame(categories, f_index, f_size):
f_dpi = 100
f_w, f_h = f_size
fig = plt.figure(figsize=(f_w / f_dpi, f_h / f_dpi), dpi=f_dpi)
ax = fig.add_subplot(111)
for k in categories.keys():
ax.plot(categories[k], label=k)
ax.fill_between(np.arange(len(categories[k])),
0,
categories[k],
alpha=0.4)
ax.legend()
ax.set_ylabel('Area %')
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)
ax.spines['left'].set_visible(False)
ax.grid(axis='y')
[t.set_visible(False) for t in ax.get_xticklines()]
# draw vertical line
ax.axvline(x=f_index)
fig.tight_layout()
imfig = mplfig_to_npimage(fig)
plt.close(fig)
h, w, _ = imfig.shape
return (h, w), imfig
def make_frame(t):
# print(t)
ax.clear()#清除画布
# ax.plot(x, sinc(x**2) + np.sin(x + 2*np.pi/duration * t), lw=3)#画图
ax.set_ylim(0, 2.5)
ax.set_xlim(0, 2.5)
# ax.set_facecolor('black')#设置当前画布背景颜色
# t=0
rot_dif = 90
rot = max(min(100*t,90+rot_dif),rot_dif)#最小90度，最大180度
rot = 90
# rot = max(100*t,rot_dif)
r = 0.3#半径
x = 0+r*np.cos(rot*math.pi/180)
y = 0+r*np.sin(rot*math.pi/180)
t1 = t
rot_dif1 = 90
rot1 = max(min(100*t1,90+rot_dif1),rot_dif1)
r1 = 0.1
x1 = 0.5+r1*np.cos(rot1*math.pi/180)
y1 = 0+r1*np.sin(rot1*math.pi/180)
plt.text(x, y, u'test',horizontalalignment='left',verticalalignment='bottom',
fontdict = {'size': 54, 'color': 'red','rotation':rot-rot_dif})
# plt.text(x1, y1, u'testhello这个是测试',
# fontdict = {'size': 30, 'color': 'red','rotation':rot1-rot_dif1,'ha':"left",'va':"bottom"})
return mplfig_to_npimage(fig)#生成一帧
def make_frame(t):
ax.clear()
ax.set_xlim(-x_max, x_max)
ax.set_ylim(-y_max, y_max)
#plt.setp([ax.get_xticklines(), ax.get_yticklines(),ax.get_xticklabels(), ax.get_yticklabels()], color='w')
#ax.set(facecolor='silver')
i = int(t * fps)
for e in range(0, N_addfig, 3):
pos = np.transpose(data[0:2, i, :]) #data[0,i,:]
col = data[2, i, :] * data[2, i, :] + data[3, i, :] * data[3, i, :]
#C = m.set_array(yy)
#s=(e+1)*1.2
s = 8
ax.scatter(pos[:, 0],
pos[:, 1],
c=col,
alpha=1,
marker='o',
s=s,
cmap=cmap,
norm=norm)
i = i + 3
ax.set_title('Time:' + str(round((i - 1.0) / frame_time + 0.001, 2)) +
's')
return mplfig_to_npimage(fig_mpl)
def make_frame_mpl(t):
global pdate,phour,popen,phigh,plow,pclose
global displaynum,frame
global xindex
global xhour,xopen,xhigh,xlow,xclose
ax_mpl.clear()
ax_mpl.grid()
update_frame()
ax_mpl.set_title(str(pdate[frame])+" "+str(phour[frame])+" "+str(xclose[displaynum-1]))
up = np.array( [ True if po < pc and po != None else False for po, pc in zip(xopen,xclose)] )
down = np.array( [ True if po > pc and po != None else False for po, pc in zip(xopen,xclose)] )
side = np.array( [ True if po == pc and po != None else False for po, pc in zip(xopen,xclose)] )
tbase= np.array( [ True if ho == 0 and ho != None else False for ho in xhour] )
ax_mpl.set_ylim(xlow.min()*0.999,xhigh.max()*1.001)
ax_mpl.vlines(xindex, xopen, xopen+[0.00001], color='black', linewidth=3.0, label='_nolegend_')
if True in up:
ax_mpl.vlines(xindex[up] , xlow[up] , xhigh[up] , color='red' , linewidth=0.6, label='_nolegend_')
ax_mpl.vlines(xindex[up] , xopen[up] , xclose[up] , color='red' , linewidth=3.0, label='_nolegend_')
if True in down:
ax_mpl.vlines(xindex[down], xlow[down] , xhigh[down] , color='green', linewidth=0.6, label='_nolegend_')
ax_mpl.vlines(xindex[down], xopen[down], xclose[down], color='green', linewidth=3.0, label='_nolegend_')
if True in side:
ax_mpl.vlines(xindex[side], xlow[side] , xhigh[side] , color='black', linewidth=0.6, label='_nolegend_')
ax_mpl.vlines(xindex[side], xopen[side], xclose[side], color='black', linewidth=3.0, label='_nolegend_')
if True in tbase:
ax_mpl.vlines(xindex[tbase], xlow.min()*0.999, xhigh.max()*1.001 , color='black', linewidth=0.6, label='_nolegend_')
return mplfig_to_npimage(fig_mpl) # RGB image of the figure
def specptrogram_raw_to_image_arrays(x, y_array):
"""
Takes one array of not changing x values and the corresponding arrays of y values and produces len(y_array) plots
:param x: array-like, contains x values
:param y_array: list of array-like, each entry must be of the same length as x
:return: list of len(y_array)
"""
# ensure same x- and y-axis for all graphs
y_flat = np.array(y_array).flatten()
logger.debug(f"x_shape: {np.shape(x)}, y_shape: {np.shape(y_array)}")
xlim = (min(x), max(x))
ylim = (max((1e-20, min(y_flat))), max(y_flat))
xlabel = 'Frequency'
ylabel = 'Volume'
fig, ax = plt.subplots()
line, = ax.plot(x, np.zeros(len(x)), ls='-')
ax.set_xscale('log')
ax.set_yscale('log')
ax.set_xlabel(xlabel)
ax.set_ylabel(ylabel)
ax.set_xlim(xlim)
ax.set_ylim(ylim)
images = list()
for y in tqdm(y_array, desc='making graphs'):
mask = np.array(y) > 0
this_x, this_y = np.array(x)[mask], np.array(y)[mask]
line.set_data(this_x, this_y)
images.append(mplfig_to_npimage(fig))
logger.debug(f'returning list of length {len(images)}')
return images
def make_frame(t):
"""Deklarace callback funkce zavolane pri renderingu kazdeho snimku videa."""
axis.clear()
global max
# celkový počet vypočtených bodů na Lorenzově atraktoru
n = 10 + max * 10
ax = fig.gca(projection='3d')
max += 1
# rozměry grafu ve směru osy x
ax.set_xlim(-30, 30)
# rozměry grafu ve směru osy y
ax.set_ylim(-30, 30)
# rozměry grafu ve směru osy z
ax.set_zlim(0, 50)
draw_attractor(ax, n, 0.0, 1.0, 0.95)
draw_attractor(ax, n, 0.0, 1.0, 1.25)
# konverze na objekt typu "frame"
return mplfig_to_npimage(fig)
def animation(self, t):
self.update()
self.ax.clear()
plt.title('Gray-Scott Model')
self.ax.imshow(self.u, interpolation='nearest', cmap=self.color)
plt.axis('off')
return mplfig_to_npimage(self.fig)
def make_frame_mpl(t):
if (t // 1) % 2:
model.meanfield_coordinate_descent_step()
else:
model.resample_model()
model.plot(update=True,draw=False)
return mplfig_to_npimage(fig)
def make_frame_mpl(t):
i = int(t*40)
n = 1. / (pdist(X_iter[..., i], "sqeuclidean") + 1)
Q = n / (2.0 * np.sum(n))
Q = squareform(Q)
im.set_data(Q)
return mplfig_to_npimage(f)
def make_gif(u):
newX,newY = X[u*40],Y[u*40]
scat.set_offsets(np.transpose(np.vstack([newX,newY])))
newx=[x[k][u*40] for k in range(120)]
newy=[y[k][u*40] for k in range(120)]
scatt.set_offsets(np.transpose(np.vstack([newx,newy])))
return mplfig_to_npimage(fig_mpl)
def make_frame(t):
""" returns an image of the frame at time t """
# ... create the frame with any library
fitness = fitness_list[int(t)]
__sum_fit = sum(fitness)
__mean_fit = float(__sum_fit) / float(len(fitness))
from scipy.stats import tstd, iqr, variation, entropy
__sd_fit = tstd(fitness)
__iqr = iqr(fitness)
__v = variation(fitness)
__e = entropy(fitness)
fig = plt.figure()
plt.hist(fitness) # ,bins=int(params['POPULATION_SIZE']*0.1))
plt.title("Moving Point - Population Fitness Histogram - Generation " +
str(int(t)))
plt.axis([0, 20000, 0, params['POPULATION_SIZE']])
plt.ylabel('#Individuals')
plt.xlabel('Fitness')
plt.grid(True)
__hist_text = "$\mu=" + "{0:.2f}".format(
__mean_fit) + ",\ \sigma=" + "{0:.2f}".format(
__sd_fit) + ",\ entropy=" + "{0:.2f}".format(
__e) + ",\ iqr=" + "{0:.2f}".format(__iqr) + "$"
plt.text(1000, params['POPULATION_SIZE'] * .9, __hist_text)
return mplfig_to_npimage(fig) # (Height x Width x 3) Numpy array
def update(t):
global dt,ddt,v,prob,x0f,y0f,x0p,y0p,x0b,y0b,n
prova = t/(8.0*dt) + ddt #every 4 time steps, ddt is a small increment for the int to work properly
Npart = 1 + int((prova))
xf = np.empty([Npart]) #x-positions of the forward-particles
yf = np.empty([Npart]) #y-positions of the forward-particles
xb = np.empty([Npart]) #x-positions of the backward-particles
yb = np.empty([Npart]) #y-positions of the backward-particles
xp = np.empty([Npart]) #x-positions of the previous-particles
yp = np.empty([Npart]) #y-positions of the previous-particles
for j in range(0,Npart):
if n[j]==0: #if it's the first time that changes
xp[j] = x0p[j]
yp[j] = y0p[j]
xf[j] = -20
yf[j] = -20
xb[j] = -20
yb[j] = -20 #stop moving (out of range)
if xp[j]>=-1.1 and xp[j]<-0.5: #if it's close to 0
x0f[j] = x0f[j] + float(v*dt) #keeps going to the right
y0f[j] = y0f[j] - float(v*dt) #keeps going onwards (y=0)
x0b[j] = x0b[j] - float(v*dt) #goes to the left
y0b[j] = y0b[j] - float(v*dt) #goes down
x0p[j] = -20
y0p[j] = -20 #stop moving
n[j]=1
else: #still not in the separating region
x0f[j] = x0f[j] + float(v*dt) #keeps going to the right
y0f[j] = y0f[j] - float(v*dt) #keeps going onwards (y=0)
x0b[j] = x0b[j] + float(v*dt) #keeps going to the right
y0b[j] = y0b[j] - float(v*dt) #keeps going onwards (y=0)
x0p[j] = x0p[j] + float(v*dt) #keeps going to the right
y0p[j] = y0p[j] - float(v*dt) #keeps going onwards (y=0)
else:
xf[j] = x0f[j]
yf[j] = y0f[j]
xb[j] = x0b[j]
yb[j] = y0b[j]
xp[j] = x0p[j]
yp[j] = y0p[j]
x0f[j] = x0f[j] + float(v*dt)
y0f[j] = y0f[j] - float(v*dt)
x0b[j] = x0b[j] - float(v*dt) #goes to the left
y0b[j] = y0b[j] - float(v*dt) #goes down
x0p[j] = -20
y0p[j] = -20 #stop moving
line.set_xdata(xf)
line.set_ydata(yf)
line2.set_xdata(xf)
line2.set_ydata(yf)
line3.set_xdata(xb)
line3.set_ydata(yb)
line4.set_xdata(xb)
line4.set_ydata(yb)
line5.set_xdata(xp)
line5.set_ydata(yp)
line6.set_xdata(xp)
line6.set_ydata(yp)
return mplfig_to_npimage(fig_mpl)
def make_frame_mpl(t):
i = int(t*40)
x = X_iter[..., i]
sc.set_offsets(x)
for j, txt in zip(range(10), txts):
xtext, ytext = np.median(x[y_data == j, :], axis=0)
txt.set_x(xtext)
txt.set_y(ytext)
return mplfig_to_npimage(f)
def make_frame_mpl(t):
self.t = t
self.update()
fig = plt.figure(figsize=(W*inches_per_pt, H*inches_per_pt))
fig, ax = self.plot_structure(fig=fig, ax=None, scale=scale)
#ax.clear()
ax.axis('off')
#fig, ax = self.plot_structure(fig=fig, ax=ax)
return mplfig_to_npimage(fig) # RGB image of the figure
def make_gif(u):
newXS,newYS = XS[u*40],YS[u*40]
newXM,newYM = XM[u*40],YM[u*40]
scat.set_offsets(np.transpose(np.vstack([newXS,newYS])));
newx=[xnew[k][u*40] for k in range(120)]
newy=[ynew[k][u*40] for k in range(120)]
scatt.set_offsets(np.transpose(np.vstack([newx,newy])));
scattt.set_offsets(np.transpose(np.vstack([newXM,newYM])));
return mplfig_to_npimage(fig_mpl)
def make_frame_mpl(t):
# line.set_ydata( zz(2*np.pi*t/duration)) # <= Update the curve
# im = Image.open(filenameList[int(t)])
im = cv2.imread(filenameList[int(t)])
print int(t)
# original_duration = im.info['duration']
# frames = [frame.copy() for frame in ImageSequence.Iterator(im)]
# plt.imshow(im)
plt.imshow(im)
return mplfig_to_npimage(fig_mpl) # RGB image of the figure
def make_frame(t):
amp, frq = local_rfft([snd[chan]], to_frames(t), rfft_len, 'sqr', rfft,
lambda x: np.sqrt(rfft_len))
frq = abs(sample_frq * frq) # Hz
thres = 0.01 # threshold for peak detection, fraction of max
peaks = get_peaks(amp, frq, thres)
fig, _ = plot_fft(frq, amp[0], title='', peaks=peaks[0])
frame = mplfig_to_npimage(fig)
matplotlib.pyplot.close()
return frame
def animate(t):
global last_i, last_frame
i = int(t)
if i == last_i:
return last_frame
fig = figures[i]
last_frame = mplfig_to_npimage(fig)
return last_frame
def make_frame_mpl_S5direct(t):
newr1=[S5direct_r1[k][t*20] for k in range(120)]
newr2=[S5direct_r2[k][t*20] for k in range(120)]
newR1=S5R1[t*20]
newR2=S5R2[t*20]
# updates the data for each frame
# this creates Nx2 matrix
scatr_S5direct.set_offsets(np.transpose(np.vstack([newr1,newr2])))
scatR_S5direct.set_offsets(np.transpose(np.vstack([newR1,newR2])))
return mplfig_to_npimage(fig_mpl_S5direct)
def update_lines(t):
plt.cla();
frame=data[int(t*10)]
x=frame[0]
y=frame[1]
u=frame[2]
v=frame[3]
scal=[]
for idx in range(0,len(x)):
scal.append((u[idx]*u[idx]+v[idx]*v[idx])*60)
ax.scatter(x, y, s=scal,c='k',alpha=0.4)
return mplfig_to_npimage(fig)
def Evolve(self, t):
# t : seconds
x = self.center[0]
y = self.center[1]
print("time:", t)
self.mand = self.mand + numpy.rot90(self.mand)
d = 2 * ((self.evolveRate) ** (t * 10))
print("radius:", d)
self.mand = self.GetMandelbort(cx=x, cy=y, d=d, border_length=200)
self.GenerateImg(dpi=200, cx=x, cy=y, bgcolor=self.MyColor)
return mplfig_to_npimage(fig=self.figure)
pass
def animate(t):
global last_i, last_frame
i = int(t)
if i == last_i:
return last_frame
xn = x + np.sin(2 * np.pi * time[i] / 10.0)
yn = y + np.cos(2 * np.pi * time[i] / 8.0)
p[0].set_data(xn, yn)
last_i = i
last_frame = mplfig_to_npimage(fig)
return last_frame
def make_frame(t):
plt.clf()
im = plt.contourf(data[int(t * size / duration)])
plt.clim(-60, 40)
plt.colorbar()
def setvisible(self, vis):
for c in self.collections: c.set_visible(vis)
im.set_visible = types.MethodType(setvisible, im)
im.axes = plt.gca()
# plt.title(self.plot_title)
return mplfig_to_npimage(fig)
def make_frame(t):
ax.clear()
ax.axis('off')
ax.set_title("SVC classification", fontsize=16)
classifier = svm.SVC(gamma=2, C=1)
# the varying weights make the points appear one after the other
weights = np.minimum(1, np.maximum(0, t**2+10-np.arange(50)))
classifier.fit(X, Y, sample_weight=weights)
Z = classifier.decision_function(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
ax.contourf(xx, yy, Z, cmap=plt.cm.bone, alpha=0.8,
vmin=-2.5, vmax=2.5, levels=np.linspace(-2,2,20))
ax.scatter(X[:,0], X[:,1], c=Y, s=50*weights, cmap=plt.cm.bone)
return mplfig_to_npimage(fig)
def make_tsne_frame(t):
i = int(t*40)
x = X_iter[..., i]
if arg.components == 2:
scat.set_offsets(x)
else: # components = 3D
# manually set private offsets bc: matplotlib is stupid
x = np.swapaxes(x,0,1).tolist()
scat._offsets3d = x
''' TODO
for j, txt in zip(range(10), txts):
xtext, ytext = np.median(x[y == j, :], axis=0)
txt.set_x(xtext)
txt.set_y(ytext)
'''
return mplfig_to_npimage(fig)
def make_frame(t):
fig = plt.figure()
print(t)
# trim the number of points
X_ = X_2d[t*diff:t*diff+diff,0]
# X = X_[:1000] # trim down
Y_ = X_2d[t*diff:t*diff+diff,1]
# Y = Y_[:1000] # trim down
fig, ax = plt.subplots()
ax.scatter(X_,Y_,c=labels)
fig.patch.set_visible(False)
ax.axis('off')
return mplfig_to_npimage(fig)
def animate(i):
#print "Animate"
line_index = 0
global list_obj, list_lines, ax1 ## list_obj is all the objects which need to be updated at each time step
for o in list_obj:
o.update()
for probe in o.getProbes():
#print probe.name, "at", probe.position
if probe.name in displayed_probes:
list_lines[line_index].set_data(probe.time_buffer, probe.value_buffer)
line_index+=1
xmin, xmax = ax1.get_xlim()
if o.t > xmax:
ax1.set_xlim(xmin, 2*xmax)
ax1.figure.canvas.draw()
NF_mp.set_data(xrange(0,width), NF.V)
NF_firing.set_data(xrange(0,width), NF.GainFunction(NF.V))
if RECORD_VIDEO:
return mplfig_to_npimage(fig)
else:
return list_lines
def make_frame(t):
fig = plt.figure()
print(t)
# get colours from hsl values
# colour = colorsys.hls_to_rgb(360*labels[t]/10, 0.5, 0.5)
my_labels = np.genfromtxt('./csv_txt_tests/mnist_ys.csv', delimiter=',')
print "label shape", my_labels.shape
# trim the labels
colour = my_labels[:1000,0]
# trim the number of points
X_ = X_2d[t*10000:t*10000+10000,0]
X = X_[:1000]
Y_ = X_2d[t*10000:t*10000+10000,1]
Y = Y_[:1000]
plt.scatter(X,Y,c=colour)
return mplfig_to_npimage(fig)
def make_frame_mpl(t):
model.resample_model()
model.plot(fig=fig,update=True,draw=False,plot_slice=plot_slice)
plt.tight_layout()
return mplfig_to_npimage(fig)
def make_frame_mpl(t):
# Update data
img.set_data(im_stack[fps * t + 1, :, :])
ax.set_title('t = {:06.3f} (ms)'.format(1e3 * t * fps * dT * cal_iter))
return mplfig_to_npimage(fig_mpl) # RGB image of the figure
def make_frame_mpl(t):
traits = model_run.next()
im.set_data(traits.reshape(10, 10))
for i, trait in enumerate(traits):
ax.texts[i].set_text("%s" % trait)
return mplfig_to_npimage(f)
def make_frame_mpl(t):
model.resample_model()
model.plot_stateseq(model.states_list[0],ax=ax,update=True,draw=False,plot_slice=plot_slice)
return mplfig_to_npimage(fig)
def video_fn(t):
"""make one frame of video"""
t += bbox.start_time
fn = getattr(profile, plot_type)
fig = fn(t=t, bbox=bbox)
return mplfig_to_npimage(fig)
def make_frame_mpl(t):
line.set_ydata( zz(2*np.pi*t/duration)) # <= Update the curve
return mplfig_to_npimage(fig_mpl) # RGB image of the figure
