def draw(self, renderer):
for coord, text in zip(self._verts3d, self.s):
xs3d, ys3d, zs3d = coord[0], coord[1], coord[2]
xs, ys, zs = proj_transform(xs3d, ys3d, zs3d, renderer.M)
self.xy = (xs, ys)
Annotation.set_text(self, text)
Annotation.draw(self, renderer)
def test_text_annotation_get_window_extent():
figure = Figure(dpi=100)
renderer = RendererAgg(200, 200, 100)
# Only text annotation
annotation = Annotation('test', xy=(0, 0))
annotation.set_figure(figure)
text = Text(text='test', x=0, y=0)
text.set_figure(figure)
bbox = annotation.get_window_extent(renderer=renderer)
text_bbox = text.get_window_extent(renderer=renderer)
eq_(bbox.width, text_bbox.width)
eq_(bbox.height, text_bbox.height)
_, _, d = renderer.get_text_width_height_descent(
'text', annotation._fontproperties, ismath=False)
_, _, lp_d = renderer.get_text_width_height_descent(
'lp', annotation._fontproperties, ismath=False)
below_line = max(d, lp_d)
# These numbers are specific to the current implementation of Text
points = bbox.get_points()
eq_(points[0, 0], 0.0)
eq_(points[1, 0], text_bbox.width)
eq_(points[0, 1], -below_line)
eq_(points[1, 1], text_bbox.height - below_line)
def test_text_annotation_get_window_extent():
figure = Figure(dpi=100)
renderer = RendererAgg(200, 200, 100)
# Only text annotation
annotation = Annotation('test', xy=(0, 0))
annotation.set_figure(figure)
text = Text(text='test', x=0, y=0)
text.set_figure(figure)
bbox = annotation.get_window_extent(renderer=renderer)
text_bbox = text.get_window_extent(renderer=renderer)
eq_(bbox.width, text_bbox.width)
eq_(bbox.height, text_bbox.height)
_, _, d = renderer.get_text_width_height_descent(
'text', annotation._fontproperties, ismath=False)
_, _, lp_d = renderer.get_text_width_height_descent(
'lp', annotation._fontproperties, ismath=False)
below_line = max(d, lp_d)
# These numbers are specific to the current implementation of Text
points = bbox.get_points()
eq_(points[0, 0], 0.0)
eq_(points[1, 0], text_bbox.width)
eq_(points[0, 1], -below_line)
eq_(points[1, 1], text_bbox.height - below_line)
def draw(self, renderer):
'''overload parent method'''
xs3d, ys3d, zs3d = self._verts3d
xs, ys, zs = proj_transform(xs3d, ys3d, zs3d, renderer.M)
self.xy=(xs,ys)
Annotation.draw(self, renderer)
def set_critical_labels(ax, k, m):
"""
Label the axis for the damping level with arrows to indicate the
half critical, critical and twice critical damping levels.
"""
cr_label = Annotation(s=r"$b_{cr}$",
xy=(2 * np.sqrt(k * m), 0),
xytext=(2 * np.sqrt(k * m), -2),
arrowprops=dict(arrowstyle='->'))
ax.add_artist(cr_label)
# Half-critical level.
cr_label05 = Annotation(s=r"$b_{cr}$",
xy=(np.sqrt(k * m), 0),
xytext=(np.sqrt(k * m), -2),
arrowprops=dict(arrowstyle='->'))
ax.add_artist(cr_label05)
# Twice critical level.
cr_label2 = Annotation(s=r"$b_{cr}$",
xy=(4 * np.sqrt(k * m), 0),
xytext=(4 * np.sqrt(k * m), -2),
arrowprops=dict(arrowstyle='->'),
annotation_clip=False)
ax.add_artist(cr_label2)
ax.set_xlabel("Arrows show half critical, critical and twice critical "
"damping levels respectfully.")
def __init__(self, s, xyz, *args, **kwargs):
Annotation.__init__(self,
"",
xy=(0, 0),
bbox=dict(boxstyle="round,pad=0.3",
fc="whitesmoke",
ec="lightgray",
lw=2),
*args,
**kwargs)
self._verts3d = xyz
self.s = s
def _get_text(txt, x, y, dx, dy, ha="center", va="center", **kwargs):
if "color" in kwargs:
textcolor = kwargs["color"]
elif "markeredgecolor" in kwargs:
textcolor = kwargs["markeredgecolor"]
ann = Annotation(txt, (x, y), xytext=(dx, dy),
xycoords='data',
textcoords="offset points",
ha=ha, va=va,
**kwargs)
ann.set_transform(IdentityTransform())
return ann
def transform_data(self):
if self.cmd == 'find_source':
self.points_list = self.idx.get_source_path(
self.search_objects, self.exclude_sources, self.depth)
elif self.cmd == 'find_target':
self.points_list = self.idx.get_target_path(
self.search_objects, self.depth)
elif self.cmd == 'find':
pl1 = self.idx.get_source_path(self.search_objects,
self.exclude_sources, self.depth)
pl2 = self.idx.get_target_path(self.search_objects, self.depth)
self.points_list = pl1 + pl2
else:
print('lol')
exit(1)
for ex in self.points_list.edges:
arrow = FancyArrowPatch(ex[0],
ex[1],
arrowstyle='-|>',
shrinkA=11,
shrinkB=11,
mutation_scale=10,
color='black',
linewidth=0.9,
connectionstyle='arc3,rad=0.02',
zorder=1)
self.arrows.append(arrow)
for point in self.points_list.points.values():
if point.name in self.search_objects:
self.annotations.append(
Annotation(point.name,
point.xy,
textcoords="offset points",
xytext=(0, 11),
ha='center',
color='red',
annotation_clip=True))
else:
self.annotations.append(
Annotation(
point.name, # this is the text
point.xy, # this is the point to label
textcoords="offset points", # how to position the text
xytext=(0, 11), # distance from text to points (x,y)
ha=
'center', # horizontal alignment can be left, right or center
annotation_clip=True))
def _get_text(txt, x, y, dx, dy, ha="center", va="center", **kwargs):
if "color" in kwargs:
textcolor = kwargs["color"]
elif "markeredgecolor" in kwargs:
textcolor = kwargs["markeredgecolor"]
ann = Annotation(txt, (x, y),
xytext=(dx, dy),
xycoords='data',
textcoords="offset points",
ha=ha,
va=va,
**kwargs)
ann.set_transform(IdentityTransform())
return ann
def _overlay_miri_ta_positions():
'''MIRI has eight target acq locations for each coronagraph which could result in persistence'''
ta_loc_spot_radius = 0.2 # arcsec
mask_name = re.match(r'MIRIM_CORON(\d+|LYOT)', aperture.AperName).groups()[0]
ta_apers = [
'MIRIM_TA{}_LL', 'MIRIM_TA{}_CLL',
'MIRIM_TA{}_LR', 'MIRIM_TA{}_CLR',
'MIRIM_TA{}_UL', 'MIRIM_TA{}_CUL',
'MIRIM_TA{}_UR', 'MIRIM_TA{}_CUR',
]
ta_apt_name_lookup = {
'UR': 1,
'UL': 2,
'LL': 3,
'LR': 4,
}
for ta_aper in ta_apers:
mask_ta_aper = ta_aper.format(mask_name)
ta_loc = aperture.tel_to_idl(_MIRI_SIAF[mask_ta_aper].V2Ref, _MIRI_SIAF[mask_ta_aper].V3Ref)
mask_artists.append(Circle(ta_loc, radius=ta_loc_spot_radius, color=GRAY_GGPLOT, alpha=0.25))
quadrant = mask_ta_aper[-2:]
mask_artists.append(Annotation(
'TA {}'.format(ta_apt_name_lookup[quadrant]),
ta_loc,
xytext=(ta_loc[0], ta_loc[1] + 0.25),
horizontalalignment='center',
alpha=0.5,
))
def plot_mantissa_arc_test(df, gravity_center, grid=True, figsize=12):
"""Draws thee Mantissa Arc Test after computing X and Y circular coordinates
for every mantissa and the center of gravity for the set
Args:
df (DataFrame): pandas DataFrame with the mantissas and the X and Y
coordinates.
gravity_center (tuple): coordinates for plottling the gravity center
grid (bool): show grid. Defaults to True.
figsize (int): figure dimensions. No need to be a tuple, since the
figure is a square.
"""
fig = plt.figure(figsize=(figsize, figsize))
ax = plt.subplot()
ax.set_facecolor(colors['b'])
ax.scatter(df.mant_x, df.mant_y, label="ARC TEST", color=colors['m'])
ax.scatter(gravity_center[0], gravity_center[1], color=colors['s'])
text_annotation = Annotation(
" Gravity Center: "
f"x({round(gravity_center[0], 3)}),"
f" y({round(gravity_center[1], 3)})",
xy=(gravity_center[0] - 0.65, gravity_center[1] - 0.1),
xycoords='data')
ax.add_artist(text_annotation)
ax.grid(True, which='both')
ax.axhline(y=0, color='k')
ax.axvline(x=0, color='k')
ax.legend(loc='lower left')
ax.set_title("Mantissas Arc Test")
plt.show(block=False)
def test_arrow_annotation_get_window_extent():
figure = Figure(dpi=100)
figure.set_figwidth(2.0)
figure.set_figheight(2.0)
renderer = RendererAgg(200, 200, 100)
# Text annotation with arrow
annotation = Annotation('',
xy=(0.0, 50.0),
xytext=(50.0, 50.0),
xycoords='figure pixels',
arrowprops={
'facecolor': 'black',
'width': 8,
'headwidth': 10,
'shrink': 0.0
})
annotation.set_figure(figure)
annotation.draw(renderer)
bbox = annotation.get_window_extent()
points = bbox.get_points()
eq_(bbox.width, 50.0)
assert_almost_equal(bbox.height, 10.0 / 0.72)
eq_(points[0, 0], 0.0)
eq_(points[0, 1], 50.0 - 5 / 0.72)
def _get_text(txt, x, y, dx, dy, ha="center", va="center", **kwargs):
if "color" in kwargs:
textcolor = kwargs["color"]
del kwargs["color"]
elif "markeredgecolor" in kwargs:
textcolor = kwargs["markeredgecolor"]
else:
import matplotlib as mpl
textcolor = mpl.rcParams['text.color']
ann = Annotation(txt, (x, y), xytext=(dx, dy),
xycoords='data',
textcoords="offset points",
color=textcolor,
ha=ha, va=va,
**kwargs)
ann.set_transform(IdentityTransform())
return ann
def __init__(self,
axes=None,
id=0,
length=5,
width=2,
label='car0',
color='black'):
self.id = id
self.v = 0
self.set_pose(0, 0, 0)
self.set_length_width(length, width)
self.label = Annotation(label, [0, 0],
size='small',
annotation_clip=False)
self.label.set_rotation_mode('anchor')
self.bbox = Line2D([], [], 2, color=color)
if axes:
axes.add_line(self.bbox)
axes.add_artist(self.label)
def plot_mantissa_arc_test(df,
gravity_center,
grid=True,
figsize=12,
save_plot=None,
save_plot_kwargs=None):
"""Draws thee Mantissa Arc Test after computing X and Y circular coordinates
for every mantissa and the center of gravity for the set
Args:
df (DataFrame): pandas DataFrame with the mantissas and the X and Y
coordinates.
gravity_center (tuple): coordinates for plottling the gravity center
grid (bool): show grid. Defaults to True.
figsize (int): figure dimensions. No need to be a tuple, since the
figure is a square.
save_plot: string with the path/name of the file in which the generated
plot will be saved. Uses matplotlib.pyplot.savefig(). File format
is infered by the file name extension.
save_plot_kwargs: dict with any of the kwargs accepted by
matplotlib.pyplot.savefig()
https://matplotlib.org/api/_as_gen/matplotlib.pyplot.savefig.html
"""
fig = plt.figure(figsize=(figsize, figsize))
ax = plt.subplot()
ax.set_facecolor(COLORS['b'])
ax.scatter(df.mant_x, df.mant_y, label="ARC TEST", color=COLORS['m'])
ax.scatter(gravity_center[0], gravity_center[1], color=COLORS['s'])
text_annotation = Annotation(
" Gravity Center: "
f"x({round(gravity_center[0], 3)}),"
f" y({round(gravity_center[1], 3)})",
xy=(gravity_center[0] - 0.65, gravity_center[1] - 0.1),
xycoords='data')
ax.add_artist(text_annotation)
ax.grid(True, which='both')
ax.axhline(y=0, color='k')
ax.axvline(x=0, color='k')
ax.legend(loc='lower left')
ax.set_title("Mantissas Arc Test")
if save_plot:
if not save_plot_kwargs:
save_plot_kwargs = {}
plt.savefig(save_plot, **save_plot_kwargs)
plt.show(block=False)
def __init__(self, ax, string, pos, dir, text_dict):
from matplotlib.text import Annotation
self.width = 0.1
self.height = 0.1
self.text = Annotation(string, pos, **text_dict)
ax.add_artist(self.text)
self.x, self.y = pos
if dir == 'top':
self.y += self.height / 2
elif dir == 'bottom':
self.y -= self.height / 2
elif dir == 'right':
self.x += self.width / 2
else:
self.x -= self.width / 2
def test_empty_annotation_get_window_extent():
figure = Figure(dpi=100)
figure.set_figwidth(2.0)
figure.set_figheight(2.0)
renderer = RendererAgg(200, 200, 100)
# Text annotation with arrow
annotation = Annotation(
'', xy=(0.0, 50.0), xytext=(0.0, 50.0), xycoords='figure pixels')
annotation.set_figure(figure)
annotation.draw(renderer)
bbox = annotation.get_window_extent()
points = bbox.get_points()
eq_(points[0, 0], 0.0)
eq_(points[1, 0], 0.0)
eq_(points[1, 1], 50.0)
eq_(points[0, 1], 50.0)
def update(frame):
circles.set_offsets(list(zip(frame[0], frame[1])))
grad_vals = map(lambda x: -1
if x == float('inf') else int(floor(x)), world.gradients)
i = 0
for label, x, y in zip(grad_vals, world.positions[0, :] + origin[0],
world.positions[1, :] + origin[1]):
anns[i].remove()
ann = Annotation(label,
xy=(x, y),
xytext=(0, 0),
textcoords='offset points',
ha='center',
va='center')
ax.add_artist(ann)
anns[i] = ann
i += 1
circles.set_color(world.colors)
circles.set_edgecolor('black')
points.set_offsets(list(zip(frame[0] + frame[2], frame[1] + frame[3])))
return circles
def plot_triple_points(triple_points, line_length=8, axis=None):
from matplotlib.text import Annotation
import matplotlib.pyplot as plt
if axis is None:
axis = plt.gca()
# Draw points
for tp in triple_points:
# Points
for p in tp.branch_points + [tp.center]:
axis.plot([p[0]], [p[1]], 'o', ms=5, color='k')
line_ends = []
for p in tp.branch_points:
center_to_p = p - tp.center
center_to_p = center_to_p / np.linalg.norm(
center_to_p) * line_length
line_ends.append(tp.center + center_to_p)
# Lines
for target in line_ends:
axis.plot([tp.center[0], target[0]], [tp.center[1], target[1]],
'--',
color='gray',
lw=2)
# Text
for i in range(3):
text_pos = (line_ends[i] + line_ends[(i + 1) % 3]) / 2
annotation = Annotation('%.1f°' % (tp.angles[i], ),
(text_pos[0], text_pos[1]),
axes=axis,
fontsize=15,
ha='center')
axis.add_artist(annotation)
def animate(i):
""" Draw motion of robots. """
for j in range(0, self.__num_agents):
x = self.__states[0, j]
y = self.__states[1, j]
th = self.__states[2, j]
pose_transformation_mat = np.array([
[np.cos(th), -1*np.sin(th), x],
[np.sin(th), np.cos(th), y],
[0, 0, 1]])
robot_body_transformed = np.dot(self.__robot_body,
pose_transformation_mat.T)
# New robot location.
self.__robot_handle[j].set_xy(robot_body_transformed[:, 0:2])
# New Annotation location.
self.__robot_number[j].remove()
self.__robot_number[j] = Annotation(
str(j + 1),
xy=(x - self.__pos_bias, y - self.__pos_bias),
xytext=(x - self.__pos_bias, y - self.__pos_bias))
self.ax.add_artist(self.__robot_number[j])
return self.__robot_handle
def test_empty_annotation_get_window_extent():
figure = Figure(dpi=100)
figure.set_figwidth(2.0)
figure.set_figheight(2.0)
renderer = RendererAgg(200, 200, 100)
# Text annotation with arrow
annotation = Annotation(
'', xy=(0.0, 50.0), xytext=(0.0, 50.0), xycoords='figure pixels')
annotation.set_figure(figure)
annotation.draw(renderer)
bbox = annotation.get_window_extent()
points = bbox.get_points()
eq_(points[0, 0], 0.0)
eq_(points[1, 0], 0.0)
eq_(points[1, 1], 50.0)
eq_(points[0, 1], 50.0)
def test_arrow_annotation_get_window_extent():
figure = Figure(dpi=100)
figure.set_figwidth(2.0)
figure.set_figheight(2.0)
renderer = RendererAgg(200, 200, 100)
# Text annotation with arrow
annotation = Annotation(
'', xy=(0.0, 50.0), xytext=(50.0, 50.0), xycoords='figure pixels',
arrowprops={
'facecolor': 'black', 'width': 8, 'headwidth': 10, 'shrink': 0.0})
annotation.set_figure(figure)
annotation.draw(renderer)
bbox = annotation.get_window_extent()
points = bbox.get_points()
eq_(bbox.width, 50.0)
assert_almost_equal(bbox.height, 10.0 / 0.72)
eq_(points[0, 0], 0.0)
eq_(points[0, 1], 50.0 - 5 / 0.72)
world.positions[1, :] + fasePos[1, :]))
fig = plt.figure(figsize=(8, 8))
ax = fig.add_axes([0, 0, 1, 1], frameon=False)
ax.set_xlim(fieldSizeX1, fieldSizeX2), ax.set_xticks([])
ax.set_ylim(fieldSizeY1, fieldSizeY2), ax.set_yticks([])
plt.gca().set_aspect('equal', adjustable='box')
grad_vals = map(lambda x: -1
if x == float('inf') else int(floor(x)), world.gradients)
anns = []
for label, x, y in zip(grad_vals, world.positions[0, :] + origin[0],
world.positions[1, :] + origin[1]):
ann = Annotation(label,
xy=(x, y),
xytext=(0, 0),
textcoords='offset points',
ha='center',
va='center')
ax.add_artist(ann)
anns.append(ann)
circles = ax.add_collection(
EllipseCollection(widths=2 * robotRadius,
heights=2 * robotRadius,
angles=0,
units='xy',
edgecolors='black',
linewidth=0.5,
facecolors=world.colors,
offsets=startPos,
transOffset=ax.transData))
def draw(self, renderer):
xs3d, ys3d, zs3d = self._verts3d
xs, ys, zs = proj_transform(xs3d, ys3d, zs3d, renderer.M)
self.xy=(xs,ys)
Annotation.draw(self, renderer)
def __init__(self, s, xyz, *args, **kwargs):
Annotation.__init__(self,s, xy=(0,0), *args, **kwargs)
self._verts3d = xyz
def __init_robot_visualize(self):
""" Initialize visualization for robots.
The body of each robot consists of different parts, namely:
grits_bot_left_wheel --> X, Y, Z points for left wheel
grits_bot_right_wheel --> X, Y, Z points for right wheel
grits_bot_tail_pin --> X, Y, Z points for tail pin
grits_bot_base --> X, Y, Z points for robot base
Each array consists for points on the graph that MATLAB/matplotlib
use to form shapes. For example:
grits_bot_base = [ 0, 0, 1;
1, 0, 1;
1, 1, 1;
0, 1, 1];
When all points are connected by lines, the grits bot base is
generated.
All robots are stored in the __robot_handle dictionary. Each robot
is a matplotlib Polygon object and can be accessed with the
appropriate index value.
"""
# Initialize variables.
robot_diameter = 0.03
num_robots = self.__num_agents
# Scale Factor (max value of single gaussian)
# scale_factor = 0.5
fig_phi = plt.figure(1)
self.figure_handle = fig_phi
self.ax = self.figure_handle.add_subplot(111)
# Plot Robotarium boundaries
self.ax.spines['top'].set_color('c')
self.ax.spines['bottom'].set_color('c')
self.ax.spines['left'].set_color('c')
self.ax.spines['right'].set_color('c')
self.ax.set_xlim([self.__boundaries[0] - self.__offset,
self.__boundaries[1] + self.__offset])
self.ax.xaxis.set_visible(False)
self.ax.set_ylim([self.__boundaries[2] - self.__offset,
self.__boundaries[3] + self.__offset])
self.ax.yaxis.set_visible(False)
# Define custom patch variables
""" Creating Grits Bot Base Matrix. """
val = np.sqrt(2) / 2
grits_bot_base = np.array([[(-1 * val), (-1 * val), 1],
[val, (-1 * val), 1],
[val, val, 1],
[(-1 * val), val, 1],
[(-1 * val), (-1 * val), 1],
[val, (-1 * val), 1]])
grits_bot_base[:, 0:2] = grits_bot_base[:, 0:2] * robot_diameter
""" Creating Grits Bot Left and Right Wheel Matrix """
grits_bot_wheel = np.array([[(-1 * val), (-1 * val), 1],
[val, (-1 * val), 1],
[val, val, 1],
[(-1 * val), val, 1]])
grits_bot_wheel[:, 0:2] = np.dot(grits_bot_wheel[:, 0:2],
np.diag([(robot_diameter / 3),
(robot_diameter / 6)]))
grits_bot_left_wheel = grits_bot_wheel + \
np.array([0, (7 / 6 * val * robot_diameter), 0])
grits_bot_right_wheel = grits_bot_wheel + \
np.array([0, (-7 / 6 * val * robot_diameter), 0])
""" Creating Grits Bot Tail Pin Matrix """
grits_bot_tail_pin_angle = np.arange((np.pi * 8 / 9),
(np.pi * 10 / 9),
(np.pi / 18))[:, np.newaxis]
grits_bot_tail_pin = np.vstack(
[np.array([[(-1 * val), np.sin(grits_bot_tail_pin_angle[0]), 1]]),
np.hstack([np.cos(grits_bot_tail_pin_angle),
np.sin(grits_bot_tail_pin_angle),
np.ones(grits_bot_tail_pin_angle.shape)]),
np.hstack([0.95 * np.cos(grits_bot_tail_pin_angle[::-1]),
0.95 * np.sin(grits_bot_tail_pin_angle[::-1]),
np.ones(grits_bot_tail_pin_angle.shape)]),
np.array([[(-1 * val),
(0.95 * np.sin(grits_bot_tail_pin_angle[0])), 1]])
])
grits_bot_tail_pin[:, 0:2] = grits_bot_tail_pin[:, 0:2] * \
robot_diameter
""" Create Low Quality Version """
grits_bot_low_quality = np.array([[(-1 * val), (-1 * val), 1],
[val, (-1 * val) + val/2, 1],
[val, val - val/2, 1],
[(-1 * val), val, 1],
[(-1 * val), (-1 * val), 1],
[val, (-1 * val) + val/2, 1]])
# Define common patch variables
if not self.__low_quality:
self.__robot_body = np.vstack([grits_bot_left_wheel,
grits_bot_right_wheel,
grits_bot_tail_pin,
grits_bot_base])
else:
self.__robot_body = grits_bot_low_quality
self.__robot_body[:, 0:2] = self.__robot_body[:, 0:2] * \
robot_diameter
# Create empty dictionary to place plt.Polygon objects.
for i in range(0, num_robots):
self.__robot_handle[i] = None
# Set initial placement of agents on graph.
for j in range(0, num_robots):
x = self.__states[0, j]
y = self.__states[1, j]
th = self.__states[2, j]
pose_transformation_mat = np.array([
[np.cos(th), -1*np.sin(th), x],
[np.sin(th), np.cos(th), y],
[0, 0, 1]])
robot_body_transformed = np.dot(self.__robot_body,
pose_transformation_mat.T)
# Visualize each robot.
self.__robot_handle[j] = plt.Polygon(
robot_body_transformed[:, 0:2])
self.__robot_handle[j].set_fill(True)
self.__robot_handle[j].set_visible(True)
self.__robot_handle[j].set_color(self.__robot_color)
self.ax.add_patch(self.__robot_handle[j])
# Annotate each new robot.
self.__robot_number[j] = Annotation(str(j+1), xy=(x-.01, y-.01),
xytext=(x-.01, y-.01))
self.ax.add_artist(self.__robot_number[j])
# Show plot.
if self.__ion:
plt.ion()
plt.show()
class Car:
def __init__(self,
axes=None,
id=0,
length=5,
width=2,
label='car0',
color='black'):
self.id = id
self.v = 0
self.set_pose(0, 0, 0)
self.set_length_width(length, width)
self.label = Annotation(label, [0, 0],
size='small',
annotation_clip=False)
self.label.set_rotation_mode('anchor')
self.bbox = Line2D([], [], 2, color=color)
if axes:
axes.add_line(self.bbox)
axes.add_artist(self.label)
def set_length_width(self, length, width):
self.length = length # x dir
self.width = width # y dir
self._bbox_x = [0, length, length, 0, 0, length * 0.3, 0]
self._bbox_y = [0, 0, width, width, 0, width * 0.5, width]
for i in range(0, len(self._bbox_x)):
self._bbox_x[i] -= length * 0.3
self._bbox_y[i] -= width * 0.5
self.bbox_x = [
[],
[],
[],
[],
[],
[],
[],
]
self.bbox_y = [
[],
[],
[],
[],
[],
[],
[],
]
def set_route(self, route, s=0, lane=0):
self.route = route
self.move_to_route(s, lane)
def move_to_route_idx(self, idx, lane=0):
self.move_to_route(self.route.s[idx], lane)
def move_to_route(self, s, lane=0):
self.s = s
self.d = self.route.to_d(lane)
self.lane = lane
self.route_idx = self.route.get_idx(s)
self.x, self.y, self.yaw = self.route.to_center_pose(s, lane)
def follow_route(self, dt=0.1):
self.s += self.v * dt
self.x, self.y, self.yaw = self.route.to_center_pose(self.s, self.lane)
self.route_idx = self.route.get_idx(self.s)
def drive(self, dt=0.1):
self.x = self.x + self.v * math.cos(self.yaw) * dt
self.y = self.y + self.v * math.sin(self.yaw) * dt
def set_pose(self, x, y, yaw):
self.x, self.y, self.yaw = x, y, yaw
def draw(self, axes=None):
# Update bounding box
for i in range(0, len(self._bbox_x)):
self.bbox_x[i], self.bbox_y[i] = self.local_to_global(
self._bbox_x[i], self._bbox_y[i])
self.bbox.set_data(self.bbox_x, self.bbox_y)
# Update label position
label_x, label_y = self.local_to_global(0.7, -0.2)
self.label.set_x(label_x)
self.label.set_y(label_y)
self.label.set_rotation(self.yaw / math.pi * 180)
return [self.bbox, self.label]
def rotate(self, x, y, yaw):
x_ = x * math.cos(yaw) - y * math.sin(yaw)
y_ = x * math.sin(yaw) + y * math.cos(yaw)
return x_, y_
def local_to_global(self, x, y):
x_, y_ = self.rotate(x, y, self.yaw)
return x_ + self.x, y_ + self.y
def global_to_local(self, x, y, offset, yaw):
x_, y_ = x - self.x, y - self.y
return self.rotate(x_, y_, -self.yaw)
def to_figure_angle(self, radian):
return -radian / math.pi * 180.
from matplotlib import pyplot as plt
from matplotlib.text import Annotation
annot = Annotation('Dude',
xy=(0.2, 0.2),
xytext=(0.5, 0.8),
arrowprops=dict(arrowstyle='->', color='r', lw=2))
fig, ax = plt.subplots()
an1 = ax._add_text(annot)
an1.set_bbox(dict(facecolor='red', boxstyle='circle', ls='dashed', lw=2))
an1.set_size(14)
arrow = an1.arrow_patch
arrow.set_linewidth(2)
arrow.set_arrowstyle('-[')
plt.show()
def annotate(axis, text, x, y):
""" Worker function for interactive scatterplot"""
text_annotation = Annotation(text, xy=(x, y), xycoords='data')
axis.add_artist(text_annotation)
y_ = x * math.sin(yaw) + y * math.cos(yaw)
return x_, y_
def local_to_global(self, x, y):
x_, y_ = self.rotate(x, y, self.yaw)
return x_ + self.x, y_ + self.y
def global_to_local(self, x, y, offset, yaw):
x_, y_ = x - self.x, y - self.y
return self.rotate(x_, y_, -self.yaw)
def to_figure_angle(self, radian):
return -radian / math.pi * 180.
t = Annotation('car0', xy=(2, 1), xytext=(3, 1.5), color='black')
def main():
print("Test Car class")
fig1 = plt.figure()
ax1 = fig1.add_subplot(111, aspect='equal')
car1 = Car(ax1, label='113')
car1.set_pose(5, 5, math.pi / 4)
car1.draw()
car2 = Car(ax1, label='5422', color='r')
car2.set_pose(0, 0, math.pi * 0.8)
car2.set_pose(0, 0, 0)
car2.draw()
def __init__(self, direction,
s_list, xy_list,
refpos,
xycoords='data',
refcoord='data',
arrowprops=None,
annotation_clip=None,
pad=0.15,
patches=None,
connection_style_func=DefaultConnectionStyleFunc(),
**kwargs):
if direction not in self._default_values.keys():
raise ValueError("direction must be one of %s" + ",".join(self._default_values.keys()))
self._direction = direction
default_values=self._default_values[direction]
INDX = default_values["INDX"]
if not ("va" in kwargs or "verticalalignment" in kwargs):
kwargs["va"] = default_values["va"]
if not ("ha" in kwargs or "horizontalalignment" in kwargs):
kwargs["ha"] = default_values["ha"]
if not "rotation" in kwargs:
kwargs["rotation"] = default_values["rot"]
if refcoord not in ["data", "axes fraction", "figure fraction"]:
raise ValueError("")
self._s_list = s_list
self._xy_list = xy_list
self._pad = pad
xytext = [0, 0]
xytext[INDX] = refpos
textcoords = ["figure pixels", "figure pixels"]
textcoords[INDX] = refcoord
self._INDX = INDX
self.arrowprops = arrowprops
self.arrow = None
if arrowprops is None:
arrowprops = dict(arrowstyle="-", relpos=default_values["relpos"])
elif arrowprops.has_key("arrowstyle") and "relpos" not in arrowprops:
arrowprops["relpos"] = default_values["relpos"]
self._connection_style_func = connection_style_func
Annotation.__init__(self, "", (0,0),
xytext=xytext,
xycoords=xycoords,
textcoords=tuple(textcoords),
arrowprops=arrowprops,
annotation_clip=annotation_clip,
**kwargs)
def annotate(axis, text, x, y):
text_annotation = Annotation(text, xy=(x, y), xycoords='data')
axis.add_artist(text_annotation)
def annotate(axis, text, x, y): # pragma: no cover
"""Create annotation at position (x,y) """
text_annotation = Annotation(text, xy=(x, y), xycoords='data')
axis.add_artist(text_annotation)
def draw(self, renderer):
xs3d, ys3d, zs3d = self._verts3d
xs, ys, zs = proj3d.proj_transform(xs3d, ys3d, zs3d, renderer.M)
Annotation.set_position(self, (xs,ys))
Annotation.draw(self, renderer)
def __init__(self, s, xyz, text_offset=[0,0,0],*args, **kwargs):
Annotation.__init__(self,s, xy=(0,0), *args, **kwargs)
self._verts3d = xyz + text_offset
self._offset = text_offset
