def draw_path(self, path, properties: Properties, z: float):
pattern = self.pattern(properties)
lineweight = self.lineweight(properties)
color = properties.color
if len(pattern) < 2:
vertices, codes = _get_path_patch_data(path)
patch = PathPatch(
Path(vertices, codes),
linewidth=lineweight,
color=color,
fill=False,
zorder=z,
)
self.ax.add_patch(patch)
else:
renderer = EzdxfLineTypeRenderer(pattern)
segments = renderer.line_segments(
path.flattening(self._config.max_flattening_distance,
segments=16))
lines = LineCollection(
[((s.x, s.y), (e.x, e.y)) for s, e in segments],
linewidths=lineweight,
color=color,
zorder=z,
)
lines.set_capstyle("butt")
self.ax.add_collection(lines)
class BatchLineCollection(object):
def __init__(self, ax):
self._ax = ax
self._lc = None
@property
def artists(self):
return [self._lc]
def draw(self, x, y, **kwargs):
segments = []
for x_i, y_i in zip(x, y):
xy_i = np.stack([x_i, y_i], axis=1)
xy_i = xy_i.reshape(-1, 1, 2)
segments_i = np.hstack([xy_i[:-1], xy_i[1:]])
segments.append(segments_i)
segments = np.concatenate(segments, axis=0)
if self._lc is None:
self._lc = PltLineCollection(segments)
self._ax.add_collection(self._lc)
else:
self._lc.set_segments(segments)
if 'color' in kwargs:
self._lc.set_color(np.reshape(kwargs['color'],
[len(segments), -1]))
if 'linewidth' in kwargs:
self._lc.set_linewidth(kwargs['linewidth'])
self._lc.set_joinstyle('round')
self._lc.set_capstyle('round')
def draw_line(self, start: Vec3, end: Vec3, properties: Properties,
z: float):
pattern = self.pattern(properties)
lineweight = self.lineweight(properties)
color = properties.color
if len(pattern) < 2:
self.ax.add_line(
Line2D(
(start.x, end.x),
(start.y, end.y),
linewidth=lineweight,
color=color,
zorder=z,
))
else:
renderer = EzdxfLineTypeRenderer(pattern)
lines = LineCollection(
[((s.x, s.y), (e.x, e.y))
for s, e in renderer.line_segment(start, end)],
linewidths=lineweight,
color=color,
zorder=z,
)
lines.set_capstyle("butt")
self.ax.add_collection(lines)
def test_cap_and_joinstyle_image():
fig, ax = plt.subplots()
ax.set_xlim([-0.5, 1.5])
ax.set_ylim([-0.5, 2.5])
x = np.array([0.0, 1.0, 0.5])
ys = np.array([[0.0], [0.5], [1.0]]) + np.array([[0.0, 0.0, 1.0]])
segs = np.zeros((3, 3, 2))
segs[:, :, 0] = x
segs[:, :, 1] = ys
line_segments = LineCollection(segs, linewidth=[10, 15, 20])
line_segments.set_capstyle("round")
line_segments.set_joinstyle("miter")
ax.add_collection(line_segments)
ax.set_title('Line collection with customized caps and joinstyle')
def test_cap_and_joinstyle_image():
fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)
ax.set_xlim([-0.5, 1.5])
ax.set_ylim([-0.5, 2.5])
x = np.array([0.0, 1.0, 0.5])
ys = np.array([[0.0], [0.5], [1.0]]) + np.array([[0.0, 0.0, 1.0]])
segs = np.zeros((3, 3, 2))
segs[:, :, 0] = x
segs[:, :, 1] = ys
line_segments = LineCollection(segs, linewidth=[10, 15, 20])
line_segments.set_capstyle("round")
line_segments.set_joinstyle("miter")
ax.add_collection(line_segments)
ax.set_title('Line collection with customized caps and joinstyle')
def colorline(
x,
y,
z=None,
cmap="inferno",
norm=plt.Normalize(0.0, 1.0),
linewidth=3,
alpha=1.0,
ax=None,
autoscale=True,
):
"""Plot a colored line with coordinates x and y.
Optionally specify colors in the array z
Optionally specify a colormap, a norm function and a line width
"""
if not isinstance(cmap, Colormap):
cmap = plt.get_cmap(cmap)
# Default colors equally spaced on [0,1]:
if z is None:
z = np.linspace(0.0, 1.0, len(x))
# Special case if a single number:
if not hasattr(z, "__iter__"): # to check for numerical input -- this is a hack
z = np.array([z])
z = np.asarray(z)
segments = make_segments(x, y)
lc = LineCollection(segments, array=z, cmap=cmap, norm=norm, linewidth=linewidth, alpha=alpha)
lc.set_capstyle("round")
if ax is None:
ax = plt.gca()
ax.add_collection(lc)
if autoscale:
ax.autoscale()
return lc
def plot(self, img, trajectories, frame_id, trail_len):
"""Plot projections of trajectories over image."""
# TODO: Make this more object oriented (no arguments) or completely functional (pass fig and ax as arguments).
img = cv2.cvtColor(
img,
cv2.COLOR_BGR2RGB) # Change color space for matplotlib plotting
# Prepare for plotting
self.ax.clear()
self.ax.axis('off')
self.ax.imshow(img, interpolation='nearest') # This takes too long...
# Handle case where not enough points for full trail length
if frame_id > trail_len:
plot_range = np.arange(frame_id - trail_len, frame_id)
else:
plot_range = np.arange(0, frame_id)
line_widths = np.linspace(0.5, 3,
trail_len) # Same line width for all drones
for i, traj in enumerate(trajectories):
color = self.cmap(i / 20)
line_colors = np.linspace(
(*color[:3], 0), color, trail_len,
axis=0) # Fade trail color to transparent
traj = traj[plot_range, np.newaxis, :]
segments = np.concatenate([traj[:-1], traj[1:]], axis=1)
lines = LineCollection(segments,
linewidths=line_widths,
colors=line_colors)
lines.set_capstyle('round')
self.ax.add_collection(lines)
# Retrieve view of render buffer. See: https://stackoverflow.com/a/62040123
self.fig.canvas.draw()
buf = self.fig.canvas.buffer_rgba()
out_frame = cv2.cvtColor(np.asarray(buf), cv2.COLOR_RGB2BGR)
return out_frame
def get_solid_line(y, c_map, width, color, onecolor=None, limits=None):
points = np.array([y[3, :], y[2, :]]).T.reshape(-1, 1, 2)
segments = np.concatenate([points[:-1], points[1:]], axis=1)
if onecolor:
color = np.array([onecolor] * len(y[0, :]))
lc = LineCollection(segments, colors=color)
else:
if limits:
norm = plt.Normalize(limits[0], limits[1])
lc = LineCollection(segments, cmap=c_map, norm=norm)
else:
lc = LineCollection(segments, cmap=c_map)
lc.set_array(color)
lc.set_linewidth(width)
#lc.set_joinstyle('bevel')
lc.set_snap(False)
lc.set_capstyle('round') #projecting
lc.set_antialiased(True)
return lc
def plot(self, ax, kws):
"""Draw the plot onto an axes, passing matplotlib kwargs."""
# Draw a test line, using the passed in kwargs. The goal here is to
# honor both (a) the current state of the plot cycler and (b) the
# specified kwargs on all the lines we will draw, overriding when
# relevant with the lineplot semantics. Note that we won't cycle
# internally; in other words, if ``hue`` is not used, all lines
# will have the same color, but they will have the color that
# ax.plot() would have used for a single line, and calling lineplot
# will advance the axes property cycle.
scout, = ax.plot([], [], **kws)
orig_color = kws.pop("color", scout.get_color())
orig_marker = kws.pop("marker", scout.get_marker())
orig_linewidth = kws.pop("linewidth",
kws.pop("lw", scout.get_linewidth()))
orig_dashes = kws.pop("dashes", "")
kws.setdefault("markeredgewidth", kws.pop("mew", .75))
kws.setdefault("markeredgecolor", kws.pop("mec", "w"))
scout.remove()
# Loop over the semantic subsets and draw a line for each
for semantics, data in self.subset_data():
hue, size, style = semantics
x, y, units = data["x"], data["y"], data.get("units", None)
if self.estimator is not None:
if self.units is not None:
err = "estimator must be None when specifying units"
raise ValueError(err)
x, y, y_ci = self.aggregate(y, x, units)
else:
y_ci = None
kws["color"] = self.palette.get(hue, orig_color)
kws["dashes"] = self.dashes.get(style, orig_dashes)
kws["marker"] = self.markers.get(style, orig_marker)
kws["linewidth"] = self.sizes.get(size, orig_linewidth)
# --- Draw the main line
line, = ax.plot([], [], **kws)
line_color = line.get_color()
line_alpha = line.get_alpha()
line_capstyle = line.get_solid_capstyle()
line.remove()
if self.units is None:
line, = ax.plot(x.values, y.values, **kws)
else:
for u in units.unique():
ax.plot(x[units == u].values, y[units == u].values, **kws)
# --- Draw the confidence intervals
if y_ci is not None:
if self.errstyle == "band":
ax.fill_between(x,
y_ci["low"],
y_ci["high"],
color=line_color,
alpha=.2)
elif self.errstyle == "bars":
ci_xy = np.empty((len(x), 2, 2))
ci_xy[:, :, 0] = x[:, np.newaxis]
ci_xy[:, :, 1] = y_ci.values
lines = LineCollection(ci_xy,
color=line_color,
alpha=line_alpha)
try:
lines.set_capstyle(line_capstyle)
except AttributeError:
pass
ax.add_collection(lines)
ax.autoscale_view()
else:
err = "`errstyle` must by 'band' or 'bars', not {}"
raise ValueError(err.format(self.errstyle))
# TODO this should go in its own method?
if self.x_label is not None:
x_visible = any(t.get_visible() for t in ax.get_xticklabels())
ax.set_xlabel(self.x_label, visible=x_visible)
if self.y_label is not None:
y_visible = any(t.get_visible() for t in ax.get_yticklabels())
ax.set_ylabel(self.y_label, visible=y_visible)
# Add legend
if self.legend:
self.add_legend_data(ax)
handles, _ = ax.get_legend_handles_labels()
if handles:
ax.legend()
figsize=(4.5, 5),
subplot_kw={'projection': 'polar'})
#ax.plot(data['phase'][idx_plt], data['radius'][idx_plt])
num_pts = idx_plt.shape[0]
res = 10
time = data['time'][idx_plt][0::res]
phase = data['phase'][idx_plt][0::res]
radius = data['radius'][idx_plt][0::res]
cnorm = mpl.colors.Normalize(vmin=0, vmax=8)
points = np.array([phase, radius]).T.reshape(-1, 1, 2)
segments = np.concatenate([points[:-1], points[1:]], axis=1)
lc = LineCollection(segments, cmap=cm.plasma, norm=cnorm)
lc.set_array(time)
lc.set_capstyle('round')
ax.add_collection(lc)
ax.set_rgrids(np.arange(0.4, 1.6, 0.4))
ax.set_rmax(1.2)
ax.set_xlabel('Hip Angle Axis', labelpad=10)
ax.set_ylabel('Hip Integral Axis', labelpad=35)
# add an axes above the main axes.
cax = fig.add_axes([0.11, 1.0, 0.8, 0.05])
cb = mpl.colorbar.ColorbarBase(cax,
cmap=cm.plasma,
norm=cnorm,
orientation='horizontal',
drawedges=False)
# change tick position to top. Tick position defaults to bottom and overlaps
# the image.
