def visualize(gt_mat, meas_mat, graph, res):
marginals = Marginals(graph, res)
keys = res.keys()
linecollection = np.zeros((0, 16, 3))
linecollection2 = np.zeros((0, 16, 3))
linecollectionobj = np.zeros((0, 3))
linecollectionobj2 = np.zeros((0, 3))
# Plot points and covariance matrices
for pose in gt_mat[1:, :]:
linecollection = plot_camera(pose, linecollection)
linecollectionobj = plot_object(gt_mat[0], linecollectionobj)
fig = plt.figure()
ax = fig.gca(projection='3d')
lc = Line3DCollection(linecollection, color='r')
ax.add_collection(lc)
# Plot points and covariance matrices
for pose in meas_mat[1:, :]:
linecollection2 = plot_camera(pose, linecollection2)
linecollectionobj2 = plot_object(meas_mat[0], linecollectionobj2)
lc2 = Line3DCollection(linecollection2, color='g')
ax.add_collection(lc2)
lco = Line3DCollection(linecollectionobj[None, :], color='r')
ax.add_collection(lco)
lco2 = Line3DCollection(linecollectionobj2[None, :], color='g')
ax.add_collection(lco2)
plt.show()
def connectome(s):
vertex1, vertex2, vertex3 = s.ch.points[s.ch.simplices[:, 0]], s.ch.points[
s.ch.simplices[:, 1]], s.ch.points[s.ch.simplices[:, 2]]
phi_avg = (vertex1 + vertex2 + vertex3) / 3.
linesv = [(tuple(phi_avg[i[0]]), tuple(phi_avg[i[1]])) for i in vconn]
colv = [(1, 0, 0, 1) for i in range(len(linesv))]
linesh = [(tuple(phi_avg[i[0]]), tuple(phi_avg[i[1]])) for i in hconn]
colh = [(0, 0, 1, 1) for i in range(len(linesh))]
colx = [(0, 1, 0, 1) for i in range(len(linesh))]
coly = [(1, 1, 0, 1) for i in range(len(linesh))]
lines = linesv + linesh
c = np.array(colv + colh)
lc1 = Line3DCollection(
linesv[int(len(linesv) / 2):], colors=colv, linewidths=3
) #[:int(5*len(linesv)/7)] [:int(len(linesv)/2)] + linesv[int(3*len(linesv)/4):]
lc2 = Line3DCollection(linesh[int(len(linesh) / 2):],
colors=colh,
linewidths=3) #[:int(5*len(linesh)/7)]
#lc3 = Line3DCollection(linesv[int(len(linesv)/2):], colors=colx, linewidths=3)
#lc4 = Line3DCollection(linesh[int(len(linesh)/2):], colors=coly, linewidths=3)
#fig, ax = pl.subplots()
#ax.add_collection(lc)
fig2 = plt.figure()
ax2 = fig2.gca(projection='3d')
#ax2.plot(phi_avg[:,0], phi_avg[:,1], phi_avg[:,2], 'r', markersize=1)
ax2.add_collection(lc1)
ax2.add_collection(lc2)
def draw_sphere(self, origin, radius, wireframe=False, **kwargs):
longitude = np.radians(np.linspace(0, 360, 16,
endpoint=False))[:, np.newaxis]
latitude = np.radians(np.linspace(-90, 90, 8,
endpoint=True))[np.newaxis, :]
z = np.sin(latitude)
r = np.cos(latitude)
x = r * np.cos(longitude)
y = r * np.sin(longitude)
unit_sphere = np.stack((x, y, np.broadcast_to(z, x.shape)), axis=-1)
sphere = unit_sphere * radius + origin
if wireframe:
parallels = np.reshape(
np.stack(
(sphere[:, 1:-1], np.roll(sphere[:, 1:-1], 1, axis=0)),
axis=2), (-1, 2, 3))
meridians = np.reshape(
np.stack((sphere, np.roll(sphere, 1, axis=1)), axis=-2)[:, 1:],
(-1, 2, 3))
self.ax.add_collection(Line3DCollection(parallels, **kwargs))
self.ax.add_collection(Line3DCollection(meridians, **kwargs))
else:
axis = ((), (0, ), (0, 1), (1, ))
quads = np.reshape(
np.stack([np.roll(sphere, 1, axis=ax) for ax in axis], axis=2),
(-1, 4, 3))
self.ax.add_collection(Poly3DCollection(quads, **kwargs))
def multicolor(ax, x, y, z, t, c, threedim=True, etho=False, cg=1):
"""multicolor plot modified from francesco."""
lw = 1
x = x[::cg]
y = y[::cg]
if threedim:
z = z[::cg]
t = t[::cg]
if threedim:
points = np.array([x, y, z]).transpose().reshape(-1, 1, 3)
segs = np.concatenate([points[:-1], points[1:]], axis=1)
lc = Line3DCollection(segs, cmap=c, lw=lw)
if etho:
lc = Line3DCollection(segs, cmap=c, lw=lw, norm=ethonorm)
lc.set_array(t)
ax.add_collection3d(lc)
ax.set_xlim(np.min(x), np.max(x))
ax.set_ylim(np.min(y), np.max(y))
ax.set_zlim(np.min(z), np.max(z))
else:
points = np.array([x, y]).transpose().reshape(-1, 1, 2)
segs = np.concatenate([points[:-1], points[1:]], axis=1)
lc = LineCollection(segs, cmap=c, lw=lw)
if etho:
lc = LineCollection(segs, cmap=c, lw=lw, norm=ethonorm)
lc.set_array(t)
ax.add_collection(lc)
ax.set_xlim(np.min(x), np.max(x))
ax.set_ylim(np.min(y), np.max(y))
return lc
def drawWhirlybird(self,phi,theta,psi): verts = [] for i in range(1,len(self.verts)): vertsTemp = rotate(self.verts[i].T,phi,theta,psi).T vertsTemp = transformXYZtoNED(vertsTemp) verts.append(vertsTemp) #print(verts) verts = np.asarray(verts) #print(verts) if self.flagInit == True: # Initialize Poly3DCollection class for each set of vertices, and # create an object handle to each one. self.PolyCollections.append(Line3DCollection([np.asarray(verts[0])],facecolor = 'black',edgecolor = 'black', lw = 2)) self.PolyCollections.append(Line3DCollection([np.asarray(verts[1])],facecolor = 'black',edgecolor = 'black', lw = 2)) self.PolyCollections.append(Poly3DCollection([np.asarray(verts[2])],facecolor = 'green',edgecolor = 'black', lw = 2)) self.PolyCollections.append(Poly3DCollection([np.asarray(verts[3])],facecolor = 'red',edgecolor = 'black', lw = 2)) # Add each Poly3DCollection object to the axes. for i in range(len(self.PolyCollections)): self.ax.add_collection3d(self.PolyCollections[i]) self.flagInit = False else: # Update the verts self.PolyCollections[0].set_segments([np.asarray(verts[0])]) self.PolyCollections[1].set_segments([np.asarray(verts[1])]) self.PolyCollections[2].set_verts([np.asarray(verts[2])]) self.PolyCollections[3].set_verts([np.asarray(verts[3])])
def update_scalarmappable(self):
if self._c_data is None:
self._gl_solid_edgecolor = self.get_color()[0]
if self._gl_solid_edgecolor is not None:
f = cc.to_rgba(self._gl_solid_edgecolor)
self._gl_edgecolor = np.tile(f, (len(self._gl_3dpath[2]),1))
else:
self._gl_edgecolor = self.to_rgba(self._c_data)
idx = (np.sum(self._gl_edgecolor[:,:3],1) != 0.0)
self._gl_edgecolor[idx,-1]=self._alpha
Line3DCollection.update_scalarmappable(self)
def create_artists_graph(self):
'''create and add to self.ax main artrist related to lattice graph'''
# initialize vertices
self.xyz = self.vertices.coords
self.x, self.y, self.z = self.xyz.T
self.update_XY_scr()
# create vertices
if self.sc is not None: # remove previous vertices points
self.ax.collections.remove(self.sc)
self.sc = self.ax.scatter(self.x, self.y, self.z, marker='o')
# create edges
if self.USE_COLLECTIONS:
if self.edges_lines is not None: # remove previous edges lines
for key, edge_col in self.edges_lines.items():
self.ax.collections.remove(edge_col)
self.edges_lines = {}
for key, edge in self.UC.edges.items():
segments = [
self.xyz[self.edges.source_target[j], :]
for j in self.edges.array_ind[key]
]
edge_col = Line3DCollection(segments)
self.ax.add_collection3d(edge_col)
self.edges_lines[key] = edge_col
else:
if self.edges_lines is not None: # remove previous lines edges
for line in self.edges_lines:
self.ax.artists.remove(line)
self.edges_lines = []
for j in range(len(self.edges.ids)):
st = list(self.edges.source_target[j])
line = Line3D(self.x[st], self.y[st], self.z[st])
self.ax.add_artist(line)
self.edges_lines.append(line)
# create latticeNet
if self.latticeNet is not None: # remove previous lattice lines
self.ax.collections.remove(self.latticeNet)
self.latticeNet = Line3DCollection(self.cluster.latticeLines,
linestyle='--',
lw=0.2)
self.ax.add_collection3d(self.latticeNet)
self.v_source_ind, self.v_target_ind = None, None
self.v_ind, self.v_active_ind = None, None
self.e_ind, self.e_active_ind = None, None
self.e_activeDist_ids = []
def plot_bg_and_mc(pbg, pmc, id=0, step=1):
df = pbg
# mind the order!
d0 = pd.DataFrame([
df['Z'][::step],
df['X'][::step],
df['Y'][::step]],
index=['z', 'x', 'y']).T
numtracks = d0.shape[0]
dd = pd.DataFrame([
df['TX'][::step]*dZ,
df['TY'][::step]*dZ],
index=['x', 'y']).T
dd.insert(loc=0, column='z', value=dZ)
d1 = d0 + dd
# print d0, d1
C = plt.cm.Blues(0.5)
lc_bg = Line3DCollection(list(zip(d0.values, d1.values)), colors=C, alpha=0.5, lw=2)
df = pmc
# mind the order!
d0 = pd.DataFrame([
df['Z'],
df['X'],
df['Y']],
index=['z', 'x', 'y']).T
numtracks = d0.shape[0]
dd = pd.DataFrame([
df['TX']*dZ,
df['TY']*dZ],
index=['x', 'y']).T
dd.insert(loc=0, column='z', value=dZ)
d1 = d0 + dd
print(d1.shape)
C = plt.cm.Reds(0.5)
lc_mc = Line3DCollection(list(zip(d0.values, d1.values)), colors=C, alpha=0.9, lw=2)
fig = plt.figure(figsize=(12,8))
ax = fig.gca(projection='3d')
ax.view_init(azim=-50, elev=10)
ax.add_collection3d(lc_mc)
ax.add_collection3d(lc_bg)
# mind the order!
ax.set_xlabel("z")
ax.set_ylabel("x")
ax.set_zlabel("y")
ax.set_xlim(0, BRICK_Z)
ax.set_ylim(0, BRICK_X)
ax.set_zlim(0, BRICK_Y)
def __init__(self, *args, **kargs):
ArtGL.__init__(self)
self.do_stencil_test = True
self._gl_3dpath = kargs.pop('gl_3dpath', None)
self._gl_offset = kargs.pop('gl_offset', (0, 0, 0.))
self._gl_edgecolor = kargs.pop('gl_edgecolor', None)
self._c_data = kargs.pop('c_data', None)
self._gl_solid_edgecolor = kargs.pop('gl_solid_edgecolor', None)
self._gl_lighting = kargs.pop('gl_lighting', True)
self._gl_array_idx = kargs.pop('array_idx', None)
self._gl_voffset = kargs.pop('view_offset', (0,0,0,0.))
self._update_ec = True
self._update_v = True
Line3DCollection.__init__(self, *args, **kargs)
def plot_datamatrix3D_multicolor(amp_datamatrix, sampletime, FPS, area_start,
area_end):
bin_length = 8 * 1.5e8 / 23.328e9
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.set_title("Raw radar data", title_font)
ax.set_xlabel("Range/m", axis_font)
ax.set_ylabel("Time/s", axis_font)
ax.set_zlabel("Amplitude", axis_font)
ax.set_zlim(-0.005, 0.005)
ax.set_xlim(0, 5)
ax.set_ylim(0, 60)
slowtime = np.arange(sampletime)
fasttime = np.arange((area_start - 1e-5), (area_end - 1e-5) + bin_length,
bin_length)
norm = plt.Normalize(amp_datamatrix.min(), amp_datamatrix.max())
for i in slowtime:
slowtime_array = np.full(len(fasttime), i)
amp_array = amp_datamatrix[i * FPS]
points = np.array([fasttime, slowtime_array,
amp_array]).T.reshape(-1, 1, 3)
segments = np.concatenate([points[:-1], points[1:]], axis=1)
# ax.plot3D(fasttime ,slowtime_array,amp_datamatrix[i*FPS] ,'blue')
lc = Line3DCollection(segments, cmap='rainbow', norm=norm)
lc.set_array(amp_array)
lc.set_linewidth(1)
line = ax.add_collection(lc)
fig.colorbar(line, ax=ax)
plt.show()
fig.savefig('test.png', dpi=600)
def __init__(self):
self.flagInit = True # Used to indicate initialization
self.fig = plt.figure()
self.ax = Axes3D(self.fig) # Create a 3D axes in the figure
# A list object that will contain the lists of vertices of the
# space ships sides.
self.verts = self.getWhirlybirdVertices()
#Create stand that won't move
stand = Line3DCollection([np.asarray(self.verts[0])],
facecolor='black',
edgecolor='black',
lw=2)
self.ax.add_collection3d(stand)
# A list that will contain handles to the Poly3DCollection
# Objects so that they can be modified.
self.PolyCollections = []
# Set axis limits
_axis_limit = 1.1
self.ax.set_zlim3d([-.65, _axis_limit])
self.ax.set_ylim3d([-_axis_limit, _axis_limit])
self.ax.set_xlim3d([-_axis_limit, _axis_limit])
# Set title and labels
self.ax.set_title('Spacecraft')
self.ax.set_xlabel('East')
self.ax.set_ylabel('North')
self.ax.set_zlabel('-Down')
# Change viewing angle
self.ax.view_init(self.ax.elev, self.ax.azim + 90)
def plotChainWithEdge(chain, edges, dist):
pts = chain
plt.ion()
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
# for b in barcodes:
xPoints = [point[0] for point in pts]
yPoints = [point[1] for point in pts]
zPoints = [point[2] for point in pts]
#Chain
# ax.plot(xPoints, yPoints, zPoints, 'b')
#Balls
# ax.scatter(xPoints, yPoints, zPoints, 'r', s=350, alpha=0.4)
#Points
ax.scatter(xPoints, yPoints, zPoints, 'r')
radius = [dist] * len(pts)
for (xi, yi, zi, ri) in zip(xPoints, yPoints, zPoints, radius):
(xs, ys, zs) = drawSphere(xi, yi, zi, ri)
# ax.plot_surface(xs, ys, zs, color="b", alpha=.1)
points = np.array([p.tolist() for p in pts])
lc = Line3DCollection(points[edges], colors='r')
#Edges
plt.gca().add_collection(lc)
plt.draw()
plt.show()
plt.pause(1000000)
def display_3D_skeleton(pos, skeleton, azim, camera_pos=None):
line_3d_segs = []
cols = []
for j, j_parent in enumerate(skeleton.parents()):
if j_parent == -1:
continue
col = 'red' if j in skeleton.joints_right() else 'black'
cols.append(col)
line_3d_segs.append([(pos[j, 0], pos[j, 1], pos[j, 2]),
(pos[j_parent, 0], pos[j_parent, 1], pos[j_parent,
2])])
lc = Line3DCollection(line_3d_segs, colors=cols, linewidths=2)
fig = plt.figure(figsize=(10, 10))
ax_3d = fig.add_subplot(1, 1, 1, projection='3d')
ax_3d.add_collection3d(lc, zdir='z')
ax_3d.view_init(elev=15., azim=azim)
# ax_3d.set_aspect('equal')
ax_3d.set_xlim3d([-4, 5])
ax_3d.set_ylim3d([-4, 5])
ax_3d.set_zlim3d([-4, 5])
if camera_pos is not None:
ax_3d.scatter(camera_pos["x"],
camera_pos["y"],
camera_pos["z"],
color="g",
s=50)
plt.show()
def show_mesh_1d(axes,
mesh,
nodecolor='k',
cellcolor='k',
aspect='equal',
linewidths=1,
markersize=20,
showaxis=False):
axes.set_aspect(aspect)
if showaxis == False:
axes.set_axis_off()
else:
axes.set_axis_on()
node = mesh.node
cell = mesh.ds.cell
dim = mesh.geo_dimension()
if dim == 1:
node = np.r_['1', node.reshape(-1, 1), np.zeros((len(node), 1))]
axes.scatter(node[:, 0], node[:, 1], color=nodecolor, s=markersize)
vts = node[cell, :]
if dim < 3:
lines = LineCollection(vts, linewidths=linewidths, colors=cellcolor)
return axes.add_collection(lines)
else:
lines = Line3DCollection(vts, linewidths=linewidths, colors=cellcolor)
return axes.add_collection3d(vts)
def show_mesh_1d(axes,
mesh,
nodecolor='k',
cellcolor='k',
aspect='equal',
linewidths=1,
markersize=20,
showaxis=False):
axes.set_aspect(aspect)
if showaxis == False:
axes.set_axis_off()
else:
axes.set_axis_on()
node = mesh.entity('node')
cell = mesh.entity('cell')
if node.shape[1] == 1:
node = np.r_['1', node, np.zeros_like(node)]
axes.scatter(node[:, 0], node[:, 1], color=nodecolor, s=markersize)
vts = node[cell, :]
GD = mesh.geo_dimension()
if GD < 3:
lines = LineCollection(vts, linewidths=linewidths, colors=cellcolor)
return axes.add_collection(lines)
else:
lines = Line3DCollection(vts, linewidths=linewidths, colors=cellcolor)
return axes.add_collection3d(vts)
def get_animManager():
"""Return axample of configured AnimationManager instance"""
# data: coordinates of nodes and links
xn = [1.1, 1.9, 0.1, 0.3, 1.6, 0.8, 2.3, 1.2, 1.7, 1.0, -0.7, 0.1, 0.1, -0.9, 0.1, -0.1, 2.1, 2.7, 2.6, 2.0]
yn = [-1.2, -2.0, -1.2, -0.7, -0.4, -2.2, -1.0, -1.3, -1.5, -2.1, -0.7, -0.3, 0.7, -0.0, -0.3, 0.7, 0.7, 0.3, 0.8, 1.2]
zn = [-1.6, -1.5, -1.3, -2.0, -2.4, -2.1, -1.8, -2.8, -0.5, -0.8, -0.4, -1.1, -1.8, -1.5, 0.1, -0.6, 0.2, -0.1, -0.8, -0.4]
group = [1, 1, 4, 4, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3]
edges = [(1, 0), (2, 0), (3, 0), (3, 2), (4, 0), (5, 0), (6, 0), (7, 0), (8, 0), (9, 0), (11, 10), (11, 3), (11, 2), (11, 0), (12, 11), (13, 11), (14, 11), (15, 11), (17, 16), (18, 16), (18, 17), (19, 16), (19, 17), (19, 18)]
xyzn = list(zip(xn, yn, zn))
segments = [(xyzn[s], xyzn[t]) for s, t in edges]
# create figure
fig = plt.figure('3D graph example')
ax = fig.gca(projection='3d')
ax.set_axis_off()
# plot vertices
ax.scatter(xn,yn,zn, marker='o', c = group, s = 64)
# plot edges
edge_col = Line3DCollection(segments, lw=0.2)
ax.add_collection3d(edge_col)
# add vertices annotation. CAUTION: might slow down animation
for j, xyz_ in enumerate(xyzn):
annotate3D(ax, s=str(j+1), xyz=xyz_, fontsize=10, xytext=(-3,3),
textcoords='offset points', ha='right',va='bottom')
# pass figure to animation manager
mng = AnimationManager(ax)
# set some initial parameters
mng.dlg.spinBox_period_rot.setValue(20)
mng.dlg.spinBox_elev.setValue(20)
return mng
def update_line(num, r, line, ax):
line[0].set_data(r[0:2, :num])
line[0].set_3d_properties(r[2, :num])
line[1].set_data([[x[num], x[num] + B[0, num]],
[y[num], y[num] + B[1, num]]])
line[1].set_3d_properties([z[num], z[num] + B[2, num]])
line[2].set_data([[x[num], x[num] + N[0, num]],
[y[num], y[num] + N[1, num]]])
line[2].set_3d_properties([z[num], z[num] + N[2, num]])
line[3].set_data([[x[num], x[num] + T[0, num]],
[y[num], y[num] + T[1, num]]])
line[3].set_3d_properties([z[num], z[num] + T[2, num]])
#line[2].set_data([r[0:2, num], r[0:2, num]+N[0:2, num]])
#line[2].set_3d_properties([r[2, num],r[2, num]+N[2, num]])
#line[3].set_data([r[0:2, num], r[0:2, num]+T[0:2, num]])
#line[3].set_3d_properties([r[2, num],r[2, num]+T[2, num]])
#fig2.clf(ax1)
#if num%50 == 0:
#ax.plot([x[num],x[num]+B[0,num]],[y[num],y[num]+ B[1,num]],[z[num], z[num]+B[2,num]],'r')
#ax.plot([x[num],x[num]+N[0,num]],[y[num],y[num]+ N[1,num]],[z[num], z[num]+N[2,num]],'b')
#ax.plot([x[num],x[num]+T[0,num]],[y[num],y[num]+ T[1,num]],[z[num], z[num]+T[2,num]],'g')
lc = Line3DCollection(segments[0:(num)],
cmap=plt.get_cmap('coolwarm'),
norm=norm)
lc.set_array(torsion[0:(num)])
lc.set_linewidth(2)
ax.add_collection3d(lc, zs=r[2, 0:num], zdir='z')
return line
def vis_graph(coords, time, out_coords, out_time, indices, splits, n=10):
splits = splits[:n + 1]
out_coords = out_coords[:n]
out_time = out_time[:n]
indices = indices[:splits[-1]]
in_indices = list(set(indices))
row_lengths = splits[1:] - splits[:-1]
fig = plt.figure()
ax = fig.gca(projection="3d")
ax.scatter(coords[in_indices, 0],
coords[in_indices, 1],
time[in_indices],
color="black")
ax.scatter(out_coords[:, 0], out_coords[:, 1], out_time, color="blue")
j = indices
x = coords[j, 0]
y = coords[j, 1]
t = time[j]
in_xyz = np.stack((x, y, t), axis=-1)
out_x = np.repeat(out_coords[:, 0], row_lengths, axis=0)
out_y = np.repeat(out_coords[:, 1], row_lengths, axis=0)
out_t = np.repeat(out_time, row_lengths, axis=0)
out_xyz = np.stack((out_x, out_y, out_t), axis=-1)
# print(out_xyz[:, :2] - in_xyz[:, :2])
segs = np.stack((in_xyz, out_xyz), axis=-2)
assert segs.shape[1:] == (2, 3)
ax.add_collection(Line3DCollection(segs))
def plot_model(ax, model, color, initial, **options):
lines = list()
for element in model.elements:
if type(element) == Truss:
node_a = element.node_a
node_b = element.node_b
a = [node_a.reference_x, node_a.reference_y, node_a.reference_z
] if initial else [node_a.x, node_a.y, node_a.z]
b = [node_b.reference_x, node_b.reference_y, node_b.reference_z
] if initial else [node_b.x, node_b.y, node_b.z]
lines.append([a, b])
elif type(element) == Spring:
location = element.node.location
if element.kx != 0:
plot_spring(ax, location, 'x', **options)
if element.ky != 0:
plot_spring(ax, location, 'y', **options)
if element.kz != 0:
plot_spring(ax, location, 'z', **options)
lc = Line3DCollection(lines, colors=color, linewidths=2)
ax.add_collection(lc)
plot_symbols(ax, model, color, initial, **options)
def plot_3d_forest_rover(roverdomain, rectangles, ntraj_points=100):
from matplotlib import pyplot as plt
from mpl_toolkits.mplot3d.art3d import Poly3DCollection, Line3DCollection
# get the cost of the current trajectory
traj_cost = roverdomain.estimate_cost()
# get points on the current trajectory
traj_points = roverdomain.traj.get_points(np.linspace(0., 1.0, ntraj_points, endpoint=True))
# convert the rectangles into lists of vertices for matplotlib
poly3d, verts, faces = generate_verts(rectangles)
ax = plt.gcf().add_subplot(111, projection='3d')
# plot start and goal
ax.scatter((roverdomain.start[0], roverdomain.goal[0]),
(roverdomain.start[1], roverdomain.goal[1]),
(roverdomain.start[2], roverdomain.goal[2]), c='k')
# plot traj
seg = (zip(traj_points[:-1, :], traj_points[1:, :]))
ax.add_collection3d(Line3DCollection(seg, colors=[(0, 1., 0, 1.)] * len(seg)))
# plot rectangles
ax.add_collection3d(Poly3DCollection(poly3d, facecolors=(0.7, 0.7, 0.7, 1.), linewidth=0.5))
# set limits of axis to be the same as domain
s_range = roverdomain.s_range
ax.set_xlim(s_range[0][0], s_range[1][0])
ax.set_ylim(s_range[0][1], s_range[1][1])
ax.set_zlim(s_range[0][2], s_range[1][2])
def add_module_hit_outline_3D_plot(self,
fig,
track_id,
hitlist=None,
copy_fig=False,
edgecolor='firebrick',
linewidth=5):
if copy_fig:
new_fig = self.copy_fig(fig)
else:
new_fig = fig
hit_modules = self.get_track_hits(track_id)[1]
if hitlist is not None:
hit_modules = hit_modules[hitlist]
ax = new_fig.axes[0]
for module in hit_modules:
module_cell = Line3DCollection(
self.module_verts_cycle[tuple(module)],
linewidth=linewidth,
edgecolor=edgecolor)
ax.add_collection3d(module_cell)
return new_fig
def plot_tree3d(ax,
tree,
diameter_scale=_DIAMETER_SCALE,
linewidth=_LINEWIDTH,
color=None,
alpha=_ALPHA):
'''Generates a figure of the tree in 3d.
If the tree contains one single point the plot will be empty \
since no segments can be constructed.
Args:
ax(matplotlib axes): on what to plot
tree(neurom.core.Tree or neurom.core.Neurite): plotted tree
diameter_scale(float): Scale factor multiplied with segment diameters before plotting
linewidth(float): all segments are plotted with this width, but only if diameter_scale=None
color(str or None): Color of plotted values, None corresponds to default choice
alpha(float): Transparency of plotted values
'''
segs = [(s[0][COLS.XYZ], s[1][COLS.XYZ]) for s in iter_segments(tree)]
linewidth = _get_linewidth(tree,
diameter_scale=diameter_scale,
linewidth=linewidth)
color = _get_color(color, tree.type),
collection = Line3DCollection(segs,
color=color,
linewidth=linewidth,
alpha=alpha)
ax.add_collection3d(collection)
_update_3d_datalim(ax, tree)
def Draw_Mu4_Outline_Region(self, verts, ininc, adj):
verts_z = (self.compounds_info[self.main_compound]["enthalpy"] - self.compounds_info[self.main_compound][self.dependent_element]*self.mu4 \
- self.compounds_info[self.main_compound][self.element_x]*verts[:,0] \
- self.compounds_info[self.main_compound][self.element_y]*verts[:,1] ) \
/ self.compounds_info[self.main_compound][self.element_z]
verts_z = verts_z.reshape((len(verts), 1))
plane_vertices = np.hstack((verts, verts_z))
for i, ininc_i in enumerate(ininc):
if len(ininc_i) < 3:
continue
ininc_i = self.Sort_Plane_Vertices(ininc_i, adj)
x = []
y = []
z = []
for v in ininc_i:
x.append(plane_vertices[v][0])
y.append(plane_vertices[v][1])
z.append(plane_vertices[v][2])
x.append(plane_vertices[ininc_i[0]][0])
y.append(plane_vertices[ininc_i[0]][1])
z.append(plane_vertices[ininc_i[0]][2])
coord = [list(zip(x, y, z))]
try:
self.path.remove()
except:
pass
self.path = Line3DCollection(coord, lw=4, color='k')
self.quaternary_phasediagram_3d_plot_axes.add_collection3d(
self.path)
def draw_polygon_coll(ax,
mesh,
tris,
sf=1,
ln=1,
pg=1,
c=[0, 0, 1],
alpha=0.1,
linewidths=0.5,
linestyles=':'):
Pcoll = []
for triID in tris:
P = []
for verID in mesh.getTri(triID):
triVertex = tuple(mesh.getVertex(verID))
P.append(triVertex)
Pcoll.append(P)
if ln == 1:
collection = Line3DCollection(Pcoll,
colors=c,
linewidths=linewidths,
linestyles=linestyles)
ax.add_collection3d(collection)
if pg == 1:
collection = Poly3DCollection(Pcoll)
collection.set_facecolor((c[0], c[1], c[2], alpha))
ax.add_collection3d(collection)
ax.set_xlim(0, SCALING_FACTOR)
ax.set_ylim(0, SCALING_FACTOR)
ax.set_zlim(0, SCALING_FACTOR)
def _colorline3d(x,
y,
z,
t=None,
cmap=plt.get_cmap('viridis'),
linewidth=1,
alpha=1.0,
ax=None):
'''
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
https://stackoverflow.com/questions/52884221/how-to-plot-a-matplotlib-line-plot-using-colormap
'''
# Default colors equally spaced on [0,1]:
if t is None:
t = np.linspace(0.25, 1.0, len(x))
if ax is None:
ax = plt.gca()
points = np.array([x, y, z]).T.reshape(-1, 1, 3)
segments = np.concatenate([points[:-1], points[1:]], axis=1)
colors = np.array([cmap(i) for i in t])
lc = Line3DCollection(segments,
colors=colors,
linewidth=linewidth,
alpha=alpha)
ax.add_collection(lc)
ax.scatter(x, y, z, c=colors, marker='*',
alpha=alpha) #Adding line markers
def plot_mesh_3D(P,
var,
bnd=None,
choice='T',
linewidth=0.5,
marker_size=3,
eps=1e-16):
if choice == 'T':
E = get_E(var)
else:
E = var
lines = []
for i in range(E.shape[0]):
lines.append([tuple(P[E[i, 0], :]), tuple(P[E[i, 1], :])])
lc = Line3DCollection(lines, colors='black', linewidth=linewidth)
fig = plt.figure()
ax = fig.gca(projection='3d')
ax.add_collection3d(lc)
if bnd is None:
c_list = 'blue'
else:
bnd_P = poly_bnd_3D(bnd[0], bnd[1], P, eps=eps)
c_list = np.where(bnd_P, 'red', 'blue')
ax.scatter(P[:, 0], P[:, 1], P[:, 2], s=marker_size, c=c_list)
xa, ya, za = np.min(P, axis=0)
xb, yb, zb = np.max(P, axis=0)
ax.set_xlim(xa, xb)
ax.set_ylim(ya, yb)
ax.set_zlim(za, zb)
plt.show()
def plot_SubTh1simp3D(q, me, u, **kwargs):
lim = kwargs.pop('lim', True)
vmin = kwargs.pop('vmin', np.min(u))
vmax = kwargs.pop('vmax', np.max(u))
fig = plt.gcf()
if len(fig.axes) > 0:
ax = fig.axes[0]
else:
ax = fig.gca(projection='3d')
U = np.mean(u[me], axis=1).reshape((me.shape[0], ))
coll = ax.add_collection(
Line3DCollection(q[me],
array=U,
norm=matplotlib.colors.Normalize(vmin=vmin,
vmax=vmax),
**kwargs))
if lim:
box = np.array([
np.min(q[:, 0]),
np.max(q[:, 0]),
np.min(q[:, 1]),
np.max(q[:, 1]),
np.min(q[:, 2]),
np.max(q[:, 2])
])
set_axes(ax, box)
return coll
def draw_lines_3d(lines,
axes,
linewidth=1.0,
linestyle='solid',
color='#000000'):
"""Creates an 3D line collection and adds it to the axis.
Parameters:
lines (list): List of ((X1, Y1, Z1), (X2, X2, Z2)) lines.
axes (object): Matplotlib axes.
linewidth (float, list): Width for the lines.
linestyle (str, list): Matplotlib line style strings.
color (str, list): Color for the lines in hex or rgb.
"""
l = len(lines)
if isinstance(linewidth, (int, float)):
linewidth = float(linewidth)
linewidth = [linewidth] * l
if isinstance(color, basestring):
color = [color] * l
# --------------------------------------------------------------------------
coll = Line3DCollection(lines,
linewidths=linewidth,
colors=color,
linestyle=linestyle,
zorder=ZORDER_LINES)
axes.add_collection(coll)
def annotate_cluster(cluster_name, cluster_civs, civ_data, X, ax):
c = []
for i in range(civ_data.shape[0]):
if civ_data.iloc[i].name in cluster_civs:
c.append(i)
center = np.mean(X[c, 0:3], axis=0)
ax.scatter(center[0],
center[1],
center[2],
s=100,
c='orange',
marker='o',
edgecolors='black')
segments = [(center, X[C, 0:3]) for C in c]
ax.add_collection3d(Line3DCollection(segments, lw=2))
ax.text3D(center[0],
center[1],
center[2],
cluster_name,
color='orange',
size=24,
horizontalalignment='center',
verticalalignment='top',
bbox=dict(alpha=0, edgecolor='w', facecolor='w'))
# ax.text3D(np.max(X[:,0],axis=0),np.max(X[:,1],axis=0),np.max(X[:,2],axis=0),cluster_name, color ='orange', size = 24,
# horizontalalignment='center', verticalalignment='top',
# bbox=dict(alpha=0, edgecolor='w', facecolor='w'))
plt.draw()
plt.pause(0.1)
def plotChainWithAllHom(chain, useNewMethod):
distM = MAT.getDistM(chain)
barcodes, info = TDA.genHom(distM, useNewMethod)
edges = []
for b in barcodes:
edges += b[0]
plt.ion()
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
# for b in barcodes:
xPoints = [point[0] for point in chain]
yPoints = [point[1] for point in chain]
zPoints = [point[2] for point in chain]
ax.scatter(xPoints, yPoints, zPoints, 'r')
points = np.array([p.tolist() for p in chain])
lc = Line3DCollection(points[edges], colors='r')
# Edges
plt.gca().add_collection(lc)
plt.draw()
plt.show()
plt.pause(1000000)
