def visualize_sweeper(sweeper, nsite):
import matplotlib.pyplot as plt
dy = 0.3
arr_dx = 0.3
r = 0.1
plt.scatter(arange(nsite), zeros(nsite), s=100, facecolor='k')
ax = plt.gca()
ax.set_ylim(-0.5, 1.)
plt.axis('equal')
for i, data in enumerate(sweeper):
if i != 0:
cc.remove()
arr.remove()
cc = plt.Circle((data[-1], dy), r)
if len(data) == 3:
if data[1] == '->':
arr = plt.Arrow(data[-1] - arr_dx - r,
dy,
arr_dx,
0,
width=0.1)
else:
arr = plt.Arrow(data[-1] + arr_dx + r,
dy,
-arr_dx,
0,
width=0.1)
ax.add_patch(cc)
ax.add_patch(arr)
plt.draw()
plt.pause(0.3)
def show(room,final, weights):
pyplot.figure(figsize=(30.,30.))
pyplot.title('MCL')
pyplot.axis([0,COMP,0,LARGURA])
pyplot.grid(b=True, color='0.75', linestyle='--')
for particle in room:
if weights[room.index(particle)] < .05:
pyplot.gca().add_patch(pyplot.Circle((particle[0],particle[1]),1.5,facecolor='#ffb266',edgecolor='#994c00', alpha=0.5))
pyplot.gca().add_patch(pyplot.Arrow(particle[0], particle[1], 3.0*m.cos(particle[2]), 3.0*m.sin(particle[2]), alpha=1., facecolor='#994c00', edgecolor='#994c00',width=1.5))
pyplot.gca().add_patch(pyplot.Circle((final[0],final[1]),1.5,facecolor='#6666ff',edgecolor='#0000cc', alpha=0.5))
pyplot.gca().add_patch(pyplot.Arrow(final[0], final[1], 3.0*m.cos(final[2]), 3.0*m.sin(final[2]), alpha=1., facecolor='#000000', edgecolor='#000000',width=1.5))
global IMG_NR
if IMG_NR == 0:
shutil.rmtree('particles')
os.mkdir('particles')
IMG_NR += 1
imagename = 'particles/Particles' + str(IMG_NR)
pyplot.savefig(imagename)
def animate(i): global force_arrow global net_force_arrow x = np.linspace(0, 10, 1000) y_data = [0,0,0,0,0,0] for y_idx in range(6): y_data[y_idx] = np.linspace(0, 0, 1000) for y_idx in range(6): for idx in range(i): y_data[y_idx][idx] = data[idx][y_idx] for y_idx in range(6): lines[y_idx].set_data(x, y_data[y_idx]) mass_1.xy = (float(data[i][2])-0.5, 0) mass_2.xy = (float(data[i][5])-1.5, -3) if i > 0: ax_mass.patches.remove(force_arrow) ax_mass.patches.remove(net_force_arrow) force_arrow = plt.Arrow(float(data[i][2]), 1, float(data[i][1]) * 10, 0, color = 'r') net_force_arrow = plt.Arrow(float(data[i][2]), 2, float(data[i][4]) * 10, 0, color = 'g') ax_mass.add_patch(force_arrow) ax_mass.add_patch(net_force_arrow) fig_mass.canvas.draw() return lines[1], lines[2], lines[3], lines[4], lines[5],
def visualization(robot, step, p, pr, weights):
""" Visualization
:param robot: the current robot object
:param step: the current step
:param p: list with particles
:param pr: list of resampled particles
:param weights: particle weights
"""
plt.figure("Robot in the world", figsize=(15., 15.))
plt.title('Particle filter, step ' + str(step))
# draw coordinate grid for plotting
grid = [0, world_size, 0, world_size]
plt.axis(grid)
plt.grid(b=True, which='major', color='0.75', linestyle='--')
plt.xticks([i for i in range(0, int(world_size), 5)])
plt.yticks([i for i in range(0, int(world_size), 5)])
# draw particles
for ind in range(len(p)):
# particle
circle = plt.Circle((p[ind].x, p[ind].y), 1., facecolor='#ffb266', edgecolor='#994c00', alpha=0.5)
plt.gca().add_patch(circle)
# particle's orientation
arrow = plt.Arrow(p[ind].x, p[ind].y, 2*cos(p[ind].orientation), 2*sin(p[ind].orientation), alpha=1., facecolor='#994c00', edgecolor='#994c00')
plt.gca().add_patch(arrow)
# draw resampled particles
for ind in range(len(pr)):
# particle
circle = plt.Circle((pr[ind].x, pr[ind].y), 1., facecolor='#66ff66', edgecolor='#009900', alpha=0.5)
plt.gca().add_patch(circle)
# particle's orientation
arrow = plt.Arrow(pr[ind].x, pr[ind].y, 2*cos(pr[ind].orientation), 2*sin(pr[ind].orientation), alpha=1., facecolor='#006600', edgecolor='#006600')
plt.gca().add_patch(arrow)
# fixed landmarks of known locations
for lm in landmarks:
circle = plt.Circle((lm[0], lm[1]), 1., facecolor='#cc0000', edgecolor='#330000')
plt.gca().add_patch(circle)
# robot's location
circle = plt.Circle((robot.x, robot.y), 1., facecolor='#6666ff', edgecolor='#0000cc')
plt.gca().add_patch(circle)
# robot's orientation
arrow = plt.Arrow(robot.x, robot.y, 2*cos(robot.orientation), 2*sin(robot.orientation), alpha=0.5, facecolor='#000000', edgecolor='#000000')
plt.gca().add_patch(arrow)
plt.savefig("output/figure_" + str(step) + ".png")
plt.close()
def show_fixed(world, V, P):
ax = plt.gca()
# darken cliff
cool = np.min(V) * 1.1
for s in world.cliff_states:
V[s.y, s.x] = cool
im = ax.imshow(V, interpolation='nearest', origin='upper')
plt.tick_params(axis='both', which='both', bottom='off', top='off',
labelbottom='off', right='off', left='off', labelleft='off')
divider = make_axes_locatable(ax)
cax = divider.append_axes("right", size="5%", pad=0.05)
plt.colorbar(im, cax=cax)
ax.text(world.initial_state[1], world.initial_state[0], 'S', ha='center', va='center', fontsize=20)
for s in world.goal_states:
ax.text(s[1], s[0], 'G', ha='center', va='center', fontsize=20)
for s in world.risky_goal_states:
ax.text(s[1], s[0], 'R', ha='center', va='center', fontsize=20)
for s in world.states():
if s in world.cliff_states:
continue
if s in world.goal_states:
continue
if s in world.risky_goal_states:
continue
a = P[s.y, s.x]
ax.add_patch(plt.Arrow(s.x + offsets[a][0], s.y + offsets[a][1], dirs[a][0], dirs[a][1], color='white'))
plt.show()
def __init__(self, world, V=None):
if V is None:
self.V = -1 * np.ones((world.height, world.width))
else:
self.V = V
# darken cliff
cool = np.min(self.V) * 1.1
for s in world.cliff_states:
self.V[s.y, s.x] = cool
plt.ion()
self.fig, self.ax = plt.subplots()
im = self.ax.imshow(self.V, interpolation='nearest', origin='upper')
plt.tick_params(axis='both', which='both', bottom='off', top='off',
labelbottom='off', right='off', left='off', labelleft='off')
divider = make_axes_locatable(self.ax)
cax = divider.append_axes("right", size="5%", pad=0.05)
plt.colorbar(im, cax=cax)
self.ax.text(world.initial_state.x, world.initial_state.y, 'S', ha='center', va='center', fontsize=20)
for s in world.goal_states:
self.ax.text(s[1], s[0], 'G', ha='center', va='center', fontsize=20)
for s in world.risky_goal_states:
self.ax.text(s[1], s[0], 'R', ha='center', va='center', fontsize=20)
self.arrow = self.ax.add_patch(plt.Arrow(0, 0, 1, 1, color='white'))
def animate(i):
patch = plt.Arrow(rp[0, i],
rp[1, i], (t / 20) * math.cos(rp[2, i]),
(t / 20) * math.sin(rp[2, i]),
width=(t / 30))
ax_anim.add_patch(patch)
return patch,
def animate(i):
global patch
global isIn, xco, yco, count, T1, T, V, k
plt.axis([-4, 4, -4, 4])
c = 0
for part in particle:
ax.patches.remove(arrows[c])
part[0] = part[0] + v * np.cos(part[2]) * 0.8
part[1] = part[1] + v * np.sin(part[2]) * 0.8
if (part[0] >= 0.999 and isIn[c] and abs(part[1]) <= 0.1):
isIn[c] = 0
V.append(k - 1)
T2 = time.time()
T.append((T2 - T1))
k -= 1
if (abs(part[1]) >= 0.999 and isIn[c]):
part[1] = 0.999 * np.sign(np.sin(part[2]))
part[2] = -part[2]
if (abs(part[0]) >= 0.999 and isIn[c]):
part[0] = 0.999 * np.sign(np.cos(part[2]))
part[2] = np.pi - part[2]
xco[c] = part[0]
yco[c] = part[1]
arrows[c] = plt.Arrow(part[0],
part[1],
np.cos(part[2]) / 8,
np.sin(part[2]) / 8,
width=0.2,
animated=True)
ax.add_patch(arrows[c])
c = c + 1
line.set_data(xco, yco)
count = count + 1
print(count)
return line
def init():
# line.set_data([], [])
# global line
ax.patches.pop(0)
line = plt.Arrow(0, 0, 0, 0)
ax.add_patch(line)
return (line, )
def animate(point):
if len(ax.patches) > 0:
ax.patches.pop(0)
patch = plt.Arrow(0, 0, point[0], point[1], width=0.1, color='k')
ax.add_patch(patch)
return patch,
def plot_callback(self, timer_event=None):
if len(self.particles) == 0:
return
# graph initialization
for particle in self.particles:
if particle.circle is not None:
particle.circle.remove()
particle.circle = plt.Circle((particle.x, particle.y),
10.,
facecolor='#66ff66',
edgecolor='#009900',
alpha=0.5)
self.ax.add_patch(particle.circle)
# particle's angle
if particle.arrow is not None:
particle.arrow.remove()
particle.arrow = plt.Arrow(particle.x,
particle.y,
20 * np.cos(particle.angle),
-20 * np.sin(particle.angle),
width=5.0)
self.ax.add_patch(particle.arrow)
plt.draw()
def animate(self, i):
if i % 50 == 49:
print(f"Visualizing frame {i + 1}")
self.time = self.timesteps[i]
if i == len(self.playback) - 2:
plt.close()
to_del = []
for agent in self.playback[self.time]:
id, x, y, gx, gy, vx, vy, rot = agent
rotx = np.cos(rot)
roty = np.sin(rot)
print(rot, rotx, roty)
self.agents[agent[0]].center = (x, y)
self.dirs[id] = plt.Arrow(x,
y,
vx,
vy,
color=COLORS[id % len(COLORS)],
width=0.5)
self.ax.add_patch(self.dirs[id])
return ([self.agents[agent_id] for agent_id in self.agents] +
[self.dirs[agent_id] for agent_id in self.dirs])
def create_arrow_map(events: pd.DataFrame,
event_type: str = "Pass",
match: str = "an unknown match",
fig=None,
ax=None,
pitch_length: int = 120,
pitch_width: int = 80,
color: str = "blue"):
"""
This functions creates a map of arrows between the start point and end point of an event.
:param events: a data frame containing events
:param event_type: a string describing the event type for which to plot arrows
:param match: a string describing the match for which the events are plotted
:param fig: a figure
:param ax: a subplot of the figure on which to plot the arrows
:param pitch_length: a integer describing the length of the pitch
:param pitch_width: a integer describing the width of the pitch
:param color: a string describing the color of the arrows
:return fig, ax: a figure containing a pitch with event arrows
"""
# Filter only relevant events
temp_df = events[events.type_name == event_type]
# Filter start and end locations
locations = pd.DataFrame(temp_df.location.to_list(),
columns=['x_start', 'y_start'])
locations[['x_end', 'y_end']] = pd.DataFrame(
temp_df[f'{event_type.lower()}_end_location'].to_list())
# Add delta_x and delta_y
locations['dx'] = locations.x_end - locations.x_start
locations['dy'] = locations.y_end - locations.y_start
# Draw pitch
fig, ax = create_pitch(pitch_length, pitch_width, fig, ax)
# Draw arrows
for i, event in locations.iterrows():
x_start, y_start, x_end, y_end, dx, dy = list(event)
pass_circle = plt.Circle((x_start, y_start), 2, color=color)
pass_circle.set_alpha(0.2)
pass_arrow = plt.Arrow(x_start,
y_start,
dx,
dy,
width=3,
color=color,
in_layout=True)
ax.add_patch(pass_circle)
ax.add_patch(pass_arrow)
# Set limits
plt.ylim(0, pitch_width)
plt.xlim(0, pitch_length)
plt.title(
f"{event_type} map of {events.player_name.unique()[0]} during {match}")
return fig, ax
def main():
tf = 30
N = 1000
time = np.linspace(0, tf, N, retstep=True)
t = time[0]
dt = time[1]
T = 10
g = 9.81
m = 2.5
pos = np.zeros((2, N))
vel = np.zeros((2, N))
theta = np.zeros((1, N))
# Euler Cromer Method
for i in range(0, N):
theta[1, i] = np.tan(pos[1, i] / pos[2, i])
vel[:, i + 1] = v[:, i] + fNoSpring(theta, T, m, g) * dt
pos[:, i + 1] = pos[:, i] + v[:, i + 1] * dt
for i in range(0, N):
plt.Circle(pos[0, i], pos[1, i])
plt.Arrow(0, 20, pos[0, i], pos[1, i], width=2)
def showImage(im, kp, imageId):
classToColor = ['', 'red', 'yellow', 'blue', 'magenta']
im = im[:, :, (2, 1, 0)]
thresh = 0.5
line = [[13, 14], [14, 4], [4, 5], [5, 6], [14, 1], [1, 2], [2, 3], \
[14, 10], [10, 11], [11, 12], [14, 7], [7, 8], [8, 9]]
c = ['b', 'g', 'r', 'c', 'm', 'y', 'k', 'w']
fig, ax = plt.subplots(figsize=(12, 12))
fig = ax.imshow(im, aspect='equal')
plt.axis('off')
fig.axes.get_xaxis().set_visible(False)
fig.axes.get_yaxis().set_visible(False)
thresh = 0.01
for j in range(14):
x, y, p = kp[j * 3 : (j + 1) * 3]
'''
if p < thresh:
continue
'''
ax.add_patch(
plt.Circle((x, y), 3,
fill=True,
color = c[1],
linewidth=2.0)
)
'''
ax.text(x, y - 2, '{:.3f}'.format(kp_scores[i, j]),
bbox=dict(facecolor='blue', alpha=0.2),
fontsize=8, color='white')
'''
for l in line:
i0 = l[0] - 1
p0 = kp[i0 * 3 : (i0 + 1) * 3]
i1 = l[1] - 1
p1 = kp[i1 * 3 : (i1 + 1) * 3]
'''
if p0[2] < thresh or p1[2] < thresh:
continue
'''
ax.add_patch(
plt.Arrow(p0[0], p0[1], p1[0] - p0[0], p1[1] - p0[1],
color = c[2])
)
plt.savefig(str(imageId) + 'regRect' , bbox_inches='tight', pad_inches=0)
def step(self, s, a):
self.arrow.remove()
arrow = plt.Arrow(s.x + offsets[a][0], s.y + offsets[a][1], dirs[a][0], dirs[a][1], color='white')
self.arrow = self.ax.add_patch(arrow)
self.fig.canvas.draw()
self.fig.canvas.flush_events()
def showImage(im, boxes, keypoints, kpType):
classToColor = ['', 'red', 'yellow', 'blue', 'magenta']
im = im[:, :, (2, 1, 0)]
fig, ax = plt.subplots(figsize=(12, 12))
fig = ax.imshow(im, aspect='equal')
plt.axis('off')
fig.axes.get_xaxis().set_visible(False)
fig.axes.get_yaxis().set_visible(False)
thresh = 0.7
line = [[13, 14], [14, 4], [4, 5], [5, 6], [14, 1], [1, 2], [2, 3], \
[14, 10], [10, 11], [11, 12], [14, 7], [7, 8], [8, 9]]
c = ['b', 'g', 'r', 'c', 'm', 'y', 'k', 'w']
for i in xrange(boxes.shape[0]):
bbox = boxes[i]
'''
ax.add_patch(
plt.Rectangle((bbox[0], bbox[1]),
bbox[2] - bbox[0],
bbox[3] - bbox[1], fill=False,
edgecolor= c[i], linewidth=2.0)
)
ax.text(bbox[0], bbox[1] - 2,
'{:d}, {:d}'.format(int(bbox[2] - bbox[0]),
int(bbox[3] - bbox[1])),
bbox=dict(facecolor='blue', alpha=0.2),
fontsize=8, color='white')
'''
keypoint = keypoints[i]
for j in range(14):
if keypoint[j * 3 + 2] <= kpType:
x, y, z = keypoint[j * 3 : (j + 1) * 3]
ax.add_patch(
plt.Circle((x, y), 3,
fill=True,
color = c[i%8],
linewidth=2.0)
)
for l in line:
i0 = l[0] - 1
p0 = keypoint[i0 * 3 : (i0 + 1) * 3]
i1 = l[1] - 1
p1 = keypoint[i1 * 3 : (i1 + 1) * 3]
if p0[2] <= kpType and p1[2] <= kpType:
ax.add_patch(
plt.Arrow(p0[0], p0[1],
float(p1[0]) - p0[0], float(p1[1]) - p0[1],
color = c[i%8])
)
def showImage(im, box, score, kp, imageIdx, boxIdx):
print(box)
print(kp)
classToColor = ['', 'red', 'yellow', 'blue', 'magenta']
im = im[:, :, (2, 1, 0)]
thresh = 0.5
line = [[13, 14], [14, 4], [4, 5], [5, 6], [14, 1], [1, 2], [2, 3], \
[14, 10], [10, 11], [11, 12], [14, 7], [7, 8], [8, 9]]
c = ['b', 'g', 'r', 'c', 'm', 'y', 'k', 'w']
fig, ax = plt.subplots(figsize=(12, 12))
fig = ax.imshow(im, aspect='equal')
plt.axis('off')
fig.axes.get_xaxis().set_visible(False)
fig.axes.get_yaxis().set_visible(False)
ax.add_patch(
plt.Rectangle((box[0], box[1]),
box[2] - box[0],
box[3] - box[1],
fill=False,
edgecolor='r',
linewidth=2.0))
prob = sum(kp[2::3]) / 14
ax.text(box[0],
box[1] - 2,
'{:.3f} {:.3f}'.format(score, prob),
bbox=dict(facecolor='blue', alpha=0.2),
fontsize=8,
color='white')
for j in range(14):
x, y, p = kp[j * 3:(j + 1) * 3]
ax.add_patch(
plt.Circle((x, y), 3, fill=True, color=c[1], linewidth=2.0))
for l in line:
i0 = l[0] - 1
p0 = kp[i0 * 3:(i0 + 1) * 3]
i1 = l[1] - 1
p1 = kp[i1 * 3:(i1 + 1) * 3]
ax.add_patch(
plt.Arrow(p0[0], p0[1], p1[0] - p0[0], p1[1] - p0[1], color=c[2]))
plt.savefig('{}_{}_repoolRect.png'.format(imageIdx, boxIdx),
bbox_inches='tight',
pad_inches=0)
def makeArtist(node, pos=np.array([0, 0]), rot=0):
"Creates an artist object from node"
nodePos = np.matmul(rotMat(rot), node.pos) + pos
circle = plt.Circle(nodePos, node.r, fill=False)
arrowbase = nodePos + node.r * np.array([0.5 * node.o, 0.5])
arrowdelta = node.r * np.array([-node.o, 0])
arrow = plt.Arrow(*arrowbase, *arrowdelta, node.r / 2, color="r")
return [circle, arrow]
def show(room, final):
pyplot.figure(figsize=(30., 30.))
pyplot.title('MCL')
pyplot.axis([0, COMP, 0, LARGURA])
pyplot.grid(b=True, color='0.75', linestyle='--')
for particle in room:
pyplot.gca().add_patch(
pyplot.Circle((particle[0], particle[1]),
15.,
facecolor='#ffb266',
edgecolor='#994c00',
alpha=0.5))
pyplot.gca().add_patch(
pyplot.Arrow(particle[0],
particle[1],
30 * m.cos(particle[2]),
30 * m.sin(particle[2]),
alpha=1.,
facecolor='#994c00',
edgecolor='#994c00',
width=15))
pyplot.gca().add_patch(
pyplot.Circle((final[0], final[1]),
15.,
facecolor='#6666ff',
edgecolor='#0000cc',
alpha=0.5))
pyplot.gca().add_patch(
pyplot.Arrow(final[0],
final[1],
30 * m.cos(final[2]),
30 * m.sin(final[2]),
alpha=1.,
facecolor='#000000',
edgecolor='#000000',
width=15))
#IMG_COUNT = IMG_COUNT + 1
pyplot.savefig('Particles')
def showImage(im, kps, gt_boxes, gt_kps):
oks, oks_full = compute_oks(kps, gt_boxes, gt_kps)
classToColor = ['', 'red', 'yellow', 'blue', 'magenta']
im = im[:, :, (2, 1, 0)]
fig, ax = plt.subplots(figsize=(12, 12))
fig = ax.imshow(im, aspect='equal')
plt.axis('off')
fig.axes.get_xaxis().set_visible(False)
fig.axes.get_yaxis().set_visible(False)
thresh = 0.7
line = [[13, 14], [14, 4], [4, 5], [5, 6], [14, 1], [1, 2], [2, 3], \
[14, 10], [10, 11], [11, 12], [14, 7], [7, 8], [8, 9]]
b = 'b'
r = 'r'
g = 'g'
c = [b, b, b, r, r, r, b, b, b, r, r, r, g, g]
c2 = [g, r, r, r, b, b, b, r, r, r, b, b, b]
for i, kp in enumerate(kps):
for j in range(14):
if kp[j * 3 + 2] == 3:
continue
x, y, z = kp[j * 3 : (j + 1) * 3]
ax.add_patch(
plt.Circle((x, y), 3,
fill=True,
color = c[j],
linewidth=2.0)
)
ax.text(x, y - 2, '{:3f}'.format(oks_full[i,j]),
bbox=dict(facecolor='blue', alpha=0.2),
fontsize=8, color='white')
for j, l in enumerate(line):
i0 = l[0] - 1
p0 = kp[i0 * 3 : (i0 + 1) * 3]
i1 = l[1] - 1
p1 = kp[i1 * 3 : (i1 + 1) * 3]
if p0[2] == 3 or p1[2] == 3:
continue
ax.add_patch(
plt.Arrow(p0[0], p0[1],
float(p1[0]) - p0[0], float(p1[1]) - p0[1],
color = c2[j])
)
def Connect_points(self, startp, nextp):
spx = startp[0][0]
spy = startp[0][1]
npx = nextp[0][0]
npy = nextp[0][1]
#as shown in sample py file, we need manhattan distance between the 2 points to draw an arrow connecting them
l1 = npx - spx
l2 = npy - spy
connect = plt.Arrow(spx, spy, l1, l2, width=0.1, color='black')
return connect
def show_board(self, move=[], arrow_color='green', ax=None):
'''
Display board with pieces
If move is given, depict an arrow showing move from move[0] to move[1]
'''
if ax is None:
fig, ax = plt.subplots()
for i in range(self.board_size):
for j in range(self.board_size):
if (i + j) % 2 == 0:
square_color = 'grey'
else:
square_color = 'white'
ax.add_artist(plt.Rectangle((i, j), 1, 1, color=square_color))
if (i, j) in move:
ax.add_artist(
plt.Circle((i + .5, j + .5),
0.4,
color='green',
fill=False))
if self.board[i, j] > 0:
color = 'red'
elif self.board[i, j] < 0:
color = 'black'
else:
continue
#print i,j
ax.add_artist(plt.Circle((i + .5, j + .5), 0.2, color=color))
if abs(self.board[i, j]) > 1:
###This piece is a king
ax.add_artist(
plt.Circle((i + .5, j + .5),
0.3,
color=color,
fill=False))
if len(move) == 2:
ax.add_artist(
plt.Arrow(move[0][0] + .5,
move[0][1] + .5, (move[1][0] - move[0][0]),
(move[1][1] - move[0][1]),
color=arrow_color,
width=.5))
plt.xlim(0, self.board_size)
plt.ylim(0, self.board_size)
plt.show()
def test_arrow():
import matplotlib.pyplot as plt
g = imgutils.galaxy()
stack = FigureStack()
fig, ax = stack.add_subplots()
ax.imshow(g)
patch = plt.Arrow(50, 50, 20, 30, width=10)
ax.add_patch(patch)
stack.show()
def create_arrows(markers: Iterable[Marker], color: Any,
width: float) -> List[plt.Arrow]:
"""Creates an arrow on each marker that represents the marker orientation and returns them."""
arrows = []
for m in markers:
x = m.position.x
y = m.position.y
dx = m.radius * scipy.cos(m.orientation)
dy = m.radius * scipy.sin(m.orientation)
arrows.append(
plt.Arrow(x - dx, y - dy, 2 * dx, 2 * dy, color=color,
width=width))
return arrows
def LeftDrag(event):
global data_index
if data_index is None: return
X[data_index] = [event.xdata,event.ydata]
x,n = PiolaTransform()
edge_plot.set_xdata(X[[0,1,2,0],0])
edge_plot.set_ydata(X[[0,1,2,0],1])
vert_plot.set_xdata(X[:,0])
vert_plot.set_ydata(X[:,1])
ax.patches.pop(0)
norm_plot = plt.Arrow(x[0],x[1],n[0],n[1],width=0.2,lw=0.1,color='r')
ax.add_patch(norm_plot)
fig.canvas.draw_idle()
def showImage(im, keypoints):
classToColor = ['', 'red', 'yellow', 'blue', 'magenta']
im = im[:, :, (2, 1, 0)]
fig, ax = plt.subplots(figsize=(12, 12))
fig = ax.imshow(im, aspect='equal')
plt.axis('off')
fig.axes.get_xaxis().set_visible(False)
fig.axes.get_yaxis().set_visible(False)
thresh = 0.7
line = [[13, 14], [14, 4], [4, 5], [5, 6], [14, 1], [1, 2], [2, 3], \
[14, 10], [10, 11], [11, 12], [14, 7], [7, 8], [8, 9]]
c = ['b', 'g', 'r', 'c', 'm', 'y', 'k', 'w']
i = 0
for key in keypoints:
keypoint = keypoints[key]
for j in range(14):
if keypoint[j * 3 + 2] == 3:
continue
x, y, z = keypoint[j * 3 : (j + 1) * 3]
ax.add_patch(
plt.Circle((x, y), 3,
fill=True,
color = c[i],
linewidth=2.0)
)
for l in line:
i0 = l[0] - 1
p0 = keypoint[i0 * 3 : (i0 + 1) * 3]
i1 = l[1] - 1
p1 = keypoint[i1 * 3 : (i1 + 1) * 3]
if p0[2] == 3 or p1[2] == 3:
continue
ax.add_patch(
plt.Arrow(p0[0], p0[1],
float(p1[0]) - p0[0], float(p1[1]) - p0[1],
color = c[i])
)
i += 1
def draw_observed(state=0, state_label=0):
radius = 0.5
x = state * delta
y = -2
pos_circle = plt.Circle((x, y), radius=radius, fill=False, color='g', lw=2)
plt.gca().add_patch(pos_circle)
plt.text(x,
y,
'$X_{%s}$' % (str(state_label)),
fontsize=12,
horizontalalignment='center',
verticalalignment='center')
arrow = plt.Arrow(x, -radius, 0, -2 + 2 * radius, width=0.25)
plt.gca().add_patch(arrow)
def animate(t):
# animate arrow
if ax1.patches:
ax1.patches.pop(0)
patch = plt.Arrow(states[t, 0],
states[t, 1],
arrow_len * np.sin(states[t, 4]),
arrow_len * np.cos(states[t, 4]),
width=0.1)
ax1.add_patch(patch)
# animate bar graph
for j, b in enumerate(bar_plot):
b.set_height(saliency[t, j])
return patch,
def plotter(self, start_pos, end_pos, color="black"):
x_s = start_pos[0]
y_s = start_pos[1]
theta = start_pos[2]
x_f = end_pos[0]
y_f = end_pos[1]
dx = x_f - x_s
dy = y_f - y_s
# head_width=0.5,length_includes_head=True, head_length=0.5,
arrow = plt.Arrow(x_s, y_s, dx, dy, color=color)
return arrow
