def test_poly3dcollection_closed(): fig = plt.figure() ax = fig.add_subplot(projection='3d') poly1 = np.array([[0, 0, 1], [0, 1, 1], [0, 0, 0]], float) poly2 = np.array([[0, 1, 1], [1, 1, 1], [1, 1, 0]], float) c1 = art3d.Poly3DCollection([poly1], linewidths=3, edgecolor='k', facecolor=(0.5, 0.5, 1, 0.5), closed=True) c2 = art3d.Poly3DCollection([poly2], linewidths=3, edgecolor='k', facecolor=(1, 0.5, 0.5, 0.5), closed=False) ax.add_collection3d(c1) ax.add_collection3d(c2)
def generate_face(location, color1, axis1, direction1): x_face = [[0, 0, 0], [0, 0, 1], [0, 1, 1], [0, 1, 0]] y_face = [[0, 0, 0], [1, 0, 0], [1, 0, 1], [0, 0, 1]] z_face = [[0, 0, 0], [1, 0, 0], [1, 1, 0], [0, 1, 0]] faces = [x_face, y_face, z_face] face = faces[axis1] for row in face: if direction1 == 1: row[axis1] += 1 for i in range(3): row[i] += location[i] face_nump = np.array(face) side = art3d.Poly3DCollection([face_nump]) side.set_edgecolor('k') side.set_facecolor(color1) collection.append(side) if verbose: axes = ['x', 'y', 'z'] print("Gnerated face at %s, along %s axis" % (location, axes[axis1]))
def plot_surface(self, sp, ax): """ Plot all the vertices points on the received axel Parameters ---------- ax : Axis The axis to draw the points on sp : space.Space The colour space for computing the gamut. """ nd_data = self.data.get_flattened( sp) # Creates a new ndarray with points points = self.get_vertices(nd_data) # ndarray with all the vertices x = points[:, 0] y = points[:, 1] z = points[:, 2] x.sort() # Sort the value from smallest to biggest value. y.sort() z.sort() for i in range(self.hull.simplices.shape[0] ): # Iterates and draws all the vertices points tri = art3d.Poly3DCollection([self.points[self.hull.simplices[i]]]) ax.add_collection(tri) # Adds created points to the ax ax.set_xlim([x[0] - (x[0] * 0.20), x[-1] + x[-1] * 0.20 ]) # Set the limits for the plot by calculating. ax.set_ylim([y[0] - (y[0] * 0.20), y[-1] + y[-1] * 0.20]) ax.set_zlim([z[0] - (z[0] * 0.20), z[-1] + z[-1] * 0.20]) plt.show()
def test_poly3dcollection_alpha(): fig = plt.figure() ax = fig.gca(projection="3d") poly1 = np.array([[0, 0, 1], [0, 1, 1], [0, 0, 0]], float) poly2 = np.array([[0, 1, 1], [1, 1, 1], [1, 1, 0]], float) c1 = art3d.Poly3DCollection( [poly1], linewidths=3, edgecolor="k", facecolor=(0.5, 0.5, 1), closed=True ) c1.set_alpha(0.5) c2 = art3d.Poly3DCollection( [poly2], linewidths=3, edgecolor="k", facecolor=(1, 0.5, 0.5), closed=False ) c2.set_alpha(0.5) ax.add_collection3d(c1) ax.add_collection3d(c2)
def plot_mesh_3d(vertices, faces, elev=45, azim=30, filename=None): """ Visualize mesh object. """ fig = plt.figure(figsize=(15, 15)) ax = fig.add_subplot(111, projection='3d') pc = art3d.Poly3DCollection(vertices[faces], linewidths=0.1, edgecolor='k') ax.add_collection(pc) # ax.scatter(points[:,0], points[:,1], points[:,2], c='red', alpha = 0.2) # ax.set_xlim(-1.0, 1.0) # ax.set_ylim(-1.0, 1.0) # ax.set_zlim(-1.0, 1.0) # ax.set_title(, fontdict={'fontsize': 20, 'fontweight': 'medium'}) ax.view_init(elev=elev, azim=azim) #print("storing ", filename) if filename is not None: plt.savefig(filename, bbox_inches='tight') else: plt.show() plt.close()
def test_poly3dcollection_alpha(): fig = plt.figure() ax = fig.add_subplot(projection='3d') poly1 = np.array([[0, 0, 1], [0, 1, 1], [0, 0, 0]], float) poly2 = np.array([[0, 1, 1], [1, 1, 1], [1, 1, 0]], float) c1 = art3d.Poly3DCollection([poly1], linewidths=3, edgecolor='k', facecolor=(0.5, 0.5, 1), closed=True) c1.set_alpha(0.5) c2 = art3d.Poly3DCollection([poly2], linewidths=3, closed=False) # Post-creation modification should work. c2.set_facecolor((1, 0.5, 0.5)) c2.set_edgecolor('k') c2.set_alpha(0.5) ax.add_collection3d(c1) ax.add_collection3d(c2)
def showSTL(self): # Get the x, y, z coordinates contained in the mesh structure that are the # vertices of the triangular faces of the object x = self.mesh.x.flatten() y = self.mesh.y.flatten() z = self.mesh.z.flatten() obj_mesh = copy.deepcopy(self.mesh) obj_mesh.transform(Transforms.newRotationMatrix('z', 90 / 180 * 3.14)) # Get the vectors that define the triangular faces that form the 3D object kong_vectors = obj_mesh.vectors # Create the 3D object from the x,y,z coordinates and add the additional array of ones to # represent the object using homogeneous coordinates kong = np.array([x.T, y.T, z.T, np.ones(x.size)]) fig = plt.figure(2) axes1 = plt.axes(projection='3d') # Plot and render the faces of the object axes1.add_collection3d(art3d.Poly3DCollection(kong_vectors)) # Plot the contours of the faces of the object axes1.add_collection3d( art3d.Line3DCollection(kong_vectors, colors='k', linewidths=0.2, linestyles='-')) # Plot the vertices of the object axes1.plot(kong[0, :], kong[1, :], kong[2, :], 'k.') # Set axes and their aspect axes1.auto_scale_xyz(kong[0, :], kong[1, :], kong[2, :]) Transforms.set_axes_equal(axes1) # Show the plots plt.show()
def plot_3d(ax, x, y, z, rec_x, rec_y, color1, color2): recx = [] recy = [] for i in range(0, len(x)): recx.append(rec_x + x[i] * np.ones(2)) recy.append(rec_y + y[i] * np.ones(2)) for t in range(0, len(z)): m = z[t] btm = np.array([[recx[t][0], recy[t][0], m], [recx[t][0], recy[t][1], m], [recx[t][1], recy[t][1], m], [recx[t][1], recy[t][0], m]]) # print(btm) side = art3d.Poly3DCollection([btm]) side.set_color(color1) side.set_facecolor(color2) # side.set_alpha(0.5) ax.add_collection3d(side) ax.set_xlim3d(-5, 5) ax.set_ylim3d(-15, 2) ax.set_zlim3d(0, z[-1]) ax.set_xlabel("x axis") ax.set_ylabel("y axis") ax.set_zlabel("time") return ax
def plot_polyhedron(polys,ax=None): #Polys is a multidimensional list such that: #polys[i]=a list/array of polygons corresponding to each polyhedron #polys[i][j]=a list/array of 3-D points corresponding to each polygon if ax==None: fig=pl.figure() ax = p3.Axes3D(fig) poly3d=art3d.Poly3DCollection(polys)#,facecolor="none",edgecolor="black") ax.add_collection3d(poly3d)
def plot(points: List[Point], tri: Delaunay, vertices: List[VoronoyPoint], edges: List[VoronoyEdge]): fig = plt.figure() # fig.set_tight_layout(True) ax = Axes3D(fig) # fig.add_subplot(111, projection='3d') ax.set_xlabel('X Label') ax.set_ylabel('Y Label') ax.set_zlabel('Z Label') x_points = [p.coords[0] for p in points] y_points = [p.coords[1] for p in points] z_points = [p.coords[2] for p in points] # визуализация триангляции # ax.plot_trisurf(x_points, y_points, z_points, triangles=tri.simplices, cmap=plt.cm.Spectral) for vertex in vertices: neibs = vertex.neighbours tmp = [*neibs, neibs[0], neibs[2], neibs[1], neibs[3]] x_points_ = [p.coords[0] for p in tmp] y_points_ = [p.coords[1] for p in tmp] z_points_ = [p.coords[2] for p in tmp] tri = art3d.Poly3DCollection([neib.coords for neib in neibs]) tri.set_alpha(0.1) # tri.set_color('grey') # ax.add_collection3d(tri) ax.plot(x_points_, y_points_, z_points_, alpha=0.1) edge_mids = [(edge.start_point + edge.finish_point) / 2 for edge in edges] x_points_e = [p.coords[0] for p in edge_mids] y_points_e = [p.coords[1] for p in edge_mids] z_points_e = [p.coords[2] for p in edge_mids] ax.scatter(x_points_e, y_points_e, z_points_e, marker='*', color='red') # исходные вершины ax.scatter(x_points, y_points, z_points, marker='*', color='green') # вершины Вороного(не shallow) x_points = [vertices[i].coords[0] for i in range(len(vertices))] y_points = [vertices[i].coords[1] for i in range(len(vertices))] z_points = [vertices[i].coords[2] for i in range(len(vertices))] ax.scatter(x_points, y_points, z_points, marker='v', color='blue') # for tunnel in tunnels: # x = [point.coords[0] for point in tunnel] # y = [point.coords[1] for point in tunnel] # z = [point.coords[2] for point in tunnel] # ax.plot(x, y, z, color='yellow') plt.show()
def draw_points(vects, S, Ks, rs, ax, r_max=None): """ Draw the vectors on multi-shell. Parameters ---------- vects : array-like shape (N, 3) Contains unit vectors. Shells should be stored consecutively. S : number of shells KS : array-lke, shpae (S,) list of integers, corresponding to number of points per shell. rs : array-like shape (S,) Shell radii. ax : the matplolib axes instance to plot in. """ v = np.asarray([0., 0., 1.]) elev = 90 azim = 0 ax.view_init(azim=azim, elev=elev) # Plot spheres outlines for r in rs: draw_shell(0.99 * r, ax) vects = np.copy(vects) vects[vects[:, 2] < 0] *= -1 if rs is None: rs = np.linspace(0., 1., S + 1)[1:] indices = np.cumsum(Ks).tolist() indices.insert(0, 0) for s, r in zip(range(S), rs): vects[indices[s]:indices[s + 1]] *= r if r_max is None: r_max = np.max(rs) for s, r in zip(range(S), rs): dots_radius = np.sqrt(r / r_max) * 0.04 color = blue_red(r / r_max) positions = vects[indices[s]:indices[s + 1]] circles = draw_circles(positions, dots_radius) ax.add_collection(art3d.Poly3DCollection(circles, facecolors=color, linewidth=0)) max_val = 0.6 * r_max ax.set_xlim(-max_val, max_val) ax.set_ylim(-max_val, max_val) ax.set_zlim(-max_val, max_val) ax.axis("off")
def draw( self, vertex_color="red", show_normals=True, show_face_sets=(), show_origin=False, auto_show=False, axes=None, random_face_colors=False, **kwargs, ): import matplotlib.pyplot as plt if axes is None: axes = plt.figure().add_subplot(111, projection="3d") positions = [v.position.swap_yz() for v in self.vertices] axes.scatter(*zip(*positions), c=vertex_color, s=1, alpha=0.1) # note y/z swapped if show_normals: normals = [v.normal.swap_yz() for v in self.vertices] for position, normal in zip(positions, normals): axes.plot(*zip(position, position + normal), c="black", alpha=0.1) if show_origin: axes.scatter(0, 0, 0, c="black", marker="x", s=5) if show_face_sets == "all": show_face_sets = tuple(range(len(self.face_sets))) if show_face_sets: import numpy as np from mpl_toolkits.mplot3d import art3d vertices = np.array( [list(v.position.swap_yz()) for v in self.vertices]) faces = [] for i, face_set in enumerate(self.face_sets): if i in show_face_sets: faces += [tri for tri in face_set.get_triangles(False)] faces = np.array(faces) face_colors = list(range(len(faces))) if random_face_colors: random.shuffle(face_colors) colors = np.array(face_colors) norm = plt.Normalize(colors.min(initial=0), colors.max(initial=1)) # noinspection PyUnresolvedReferences colors = plt.cm.rainbow(norm(colors)) pc = art3d.Poly3DCollection(vertices[faces], facecolors=colors, edgecolor="black", linewidth=0.1) axes.add_collection(pc) axes.set(**kwargs) if auto_show: plt.show()
def plot(self, robot, startState, goalState, plotConfigData): # unpack dictionary plotTitle = plotConfigData['plotTitle'] xlabel = plotConfigData['xlabel'] ylabel = plotConfigData['ylabel'] fig = plt.figure() ax = fig.gca(projection='3d') # plot the robot's trajectory in Cspace robotPath = robot.stateHistory x = [state[0][0] for state in robotPath] y = [state[1][0] for state in robotPath] z = [state[2][0] for state in robotPath] ax.plot(x, y, z, color='blue', linestyle='solid', linewidth=4, markersize=16) # plot all of the CSpace obstacles for obstacle in self.obstacles: obstaclePolygon = art3d.Poly3DCollection([obstacle], alpha=0.8) face_color = [0.5, 0.5, 1] obstaclePolygon.set_color(colors.rgb2hex(face_color)) obstaclePolygon.set_edgecolor('k') ax.add_collection3d(obstaclePolygon) pl.title(plotTitle) pl.xlabel(xlabel) pl.ylabel(ylabel) ax.set_xlim3d(2, 8) ax.set_ylim3d(2, 8) ax.set_zlim3d(0, 7) if self.shouldSavePlots: saveFName = self.baseSaveFName + '-' + plotTitle + '.png' fig = pl.gcf() fig.canvas.manager.full_screen_toggle() fig.show() fig.set_size_inches((11, 8.5), forward=False) pl.savefig(saveFName, dpi=500) print('wrote figure to: ', saveFName) return None
def __init__(self, ax, x_span, y_span, z_span, *, shade=True, alpha=1.0, facecolors=None, edgecolors=None, linewidth=0, antialiased=True): """ Parameters ax, Axes3D to contain new shape x_span, width in x-direction y_span, width in y-direction z_span, width in z-direction shade, shade faces using default lightsource, default is True linewidth, width of lines, default is 0 alpha, transparency value in domain [0,1], default is 1.0 edgecolors, color of edges facecolors, color of faces antialiased, smoother edge lines, default is True """ self.shade = shade self.facecolors = facecolors self.ax = ax if self.facecolors is None: self.facecolors = self.ax._get_lines.get_next_color() self.facecolors = np.array(mcolors.to_rgba(self.facecolors)) # Precompute verticies and normal vectors in reference configuration. self.verts = self.build_verts(x_span, y_span, z_span) self.normals = np.asarray(self.ax._generate_normals(self.verts)) # Instantiate and add collection. self.polyc = art3d.Poly3DCollection(self.verts, linewidth=linewidth, antialiased=antialiased, alpha=alpha, edgecolors=edgecolors, facecolors=self.facecolors) self.artists = (self.polyc, ) self.transform(np.zeros((3, )), np.identity(3)) self.ax.add_collection(self.polyc)
def patches(faces, vertices, **kwargs): v = [[vertices[f, :] for f in face] for face in faces] p3d = art3d.Poly3DCollection(v) # ALPHA MUST BE SET BEFORE COLOR!!! or it will be ignored. (Nice one guys.) if 'alpha' in kwargs: p3d.set_alpha(kwargs['alpha']) if 'edgecolor' in kwargs: p3d.set_edgecolor(kwargs['edgecolor']) if 'facecolor' in kwargs: p3d.set_facecolor(kwargs['facecolor']) else: p3d.set_facecolor( 'C0') # this is to make sure that the alpha is changed. plt.gca().add_collection(p3d)
def plot_polys_3d(): fe = FinElem("fe.txt", latlng=False) fig = plt.figure(figsize=plt.figaspect(1), ) ax = fig.add_subplot(111, projection="3d") verts = fe.polys triCol = ar3.Poly3DCollection(verts) z_color = np.random.uniform(size=len(verts)) triCol.set_array(z_color) triCol.set_edgecolor('k') triCol.set_linewidth(2.0) ax.add_collection(triCol) ax.set_zlabel("z") ax.set_ylabel("y") ax.set_xlabel("x") plt.show()
def place3d(self, **kwargs): override = kwargs.get("override", False) if override: del kwargs["override"] if self.hidden and not override: kwargs.update({ "linestyles": hls, "linewidths": hlw, "edgecolors": hec, "zorder": -1 }) self._poly = art3d.Poly3DCollection([[(n.x, n.y, n.z) for n in self.nodes]], **kwargs) # need to do this here because of weird issue with facecolor and alpha self._poly.set_facecolor("w") plt.gca().add_collection3d(self._poly)
def plot(self, robot, startState, goalState, plotConfigData): # unpack dictionary plotTitle = plotConfigData['plotTitle'] xlabel = plotConfigData['xlabel'] ylabel = plotConfigData['ylabel'] fig = plt.figure() ax = fig.gca(projection='3d') # plot the robot's trajectory in Cspace robotPath = robot.stateHistory x = [state[0][0] for state in robotPath] y = [state[1][0] for state in robotPath] z = [state[2][0] for state in robotPath] ax.plot(x, y, z, color='blue', linestyle='solid', linewidth=4, markersize=16) # plot all of the CSpace obstacles for obstacle in self.obstacles: obstaclePolygon = art3d.Poly3DCollection([obstacle], alpha=0.8) face_color = [0.5, 0.5, 1] obstaclePolygon.set_color(colors.rgb2hex(face_color)) obstaclePolygon.set_edgecolor('k') ax.add_collection3d(obstaclePolygon) pl.title(plotTitle) pl.xlabel(xlabel) pl.ylabel(ylabel) ax.set_xlim3d(2, 8) ax.set_ylim3d(2, 8) ax.set_zlim3d(0, 7) savePlot(fig=fig, shouldSavePlots=self.shouldSavePlots, baseSaveFName=self.baseSaveFName, plotTitle=plotTitle) return None
def __init__(self, ax, edge_num): load_segs = np.array(edge_num*[[[0, 0, 0],[1, 1, 1]]]) colors = edge_num*["k"] self.edge_num = edge_num self.load = art3d.Line3DCollection( load_segs, colors=colors, linewidths=1.5 ) ax.add_collection3d(self.load) verts = [3*[[1, 1, 1]]] self.cover = art3d.Poly3DCollection(verts) self.cover.set_facecolor(colors="k") self.cover.set_edgecolor(colors="k") self.cover.set_alpha(alpha=0.3) ax.add_collection3d(self.cover)
def cuboid(coords, dims, color, **kwargs): ''' Create a cuboid to represent the phone. Parameters ---------- coords : np.array 3x3 of floats The coordinates of the end of each axis. dims : np.array [3,] of floats The dimensions of the phone. color : string Colour of the phone. **kwargs Returns ------- art3d.Poly3DCollection A cuboid representing the phone. ''' pm = np.array([-1, 1]) sides = [] # Get the direction vector for the phone. us = dims[None, :] * coords # Get each side (3 x 2 directions) for i in range(3): for direct in pm: center = direct * us[:, i] * 0.5 j, k = [l for l in range(3) if not l == i] # Get the corners for each edge corners = [] for directj, directk in zip([-1, -1, 1, 1], [1, -1, -1, 1]): corners.append(center + 0.5 * us[:, j] * directj + 0.5 * us[:, k] * directk) sides.append(corners) sides = np.array(sides).astype(float) return art3d.Poly3DCollection(sides, facecolors=np.repeat(color, 6), **kwargs)
def plot_trias_3d(): triang = SPHTriang("sphtr.latlng") x, y, z = triang.cart.T fig = plt.figure(figsize=plt.figaspect(1), ) ax = fig.add_subplot(111, projection="3d") # from (xyz, triangle, point) to (triangle, point, xyz) verts = np.array((x, y, z)).reshape(3, -1, 3).transpose(1, 2, 0) triCol = ar3.Poly3DCollection(verts) z_color = np.random.uniform(size=verts.shape[0]) triCol.set_array(z_color) triCol.set_edgecolor('k') triCol.set_linewidth(2.0) ax.add_collection(triCol) ax.set_zlabel("z") ax.set_ylabel("y") ax.set_xlabel("x") plt.show()
def draw_points_reprojected(vects, S, Ks, rs, ax): """ Draw the vectors on a unit sphere. Parameters ---------- vects : array-like shape (N, 3) Contains unit vectors. Shells should be stored consecutively. S : number of shells KS : array-lke, shpae (S,) list of integers, corresponding to number of points per shell. rs : array-like shape (S,) shell radii. This is simply used for color mapping. ax : the matplolib axes instance to plot in. """ indices = np.cumsum(Ks).tolist() indices.insert(0, 0) v = np.asarray([0., 0., 1.]) elev = 90 azim = 0 ax.view_init(azim=azim, elev=elev) # First plot sphere outline draw_shell(0.99, ax) vects = np.copy(vects) vects[vects[:, 2] < 0] *= -1 for s, r in zip(range(S), rs): color = blue_red(r / np.max(rs)) positions = vects[indices[s]:indices[s + 1]] circles = draw_circles(positions) ax.add_collection(art3d.Poly3DCollection(circles, facecolors=color, linewidth=0)) max_val = 0.6 ax.set_xlim(-max_val, max_val) ax.set_ylim(-max_val, max_val) ax.set_zlim(-max_val, max_val) ax.axis("off")
def __init__(self, ax, radius, height, n_pts=8, shade=True, color=None): self.shade = shade self.ax = ax if color is None: color = self.ax._get_lines.get_next_color() self.color = np.array(mcolors.to_rgba(color)) # Precompute verticies and normal vectors in reference configuration. self.verts = self.build_verts(radius, height, n_pts) self.normals = np.asarray(self.ax._generate_normals(self.verts)) # Instantiate and add collection. self.polyc = art3d.Poly3DCollection(self.verts, color='b', linewidth=0, antialiased=False) self.artists = (self.polyc, ) self.transform(np.zeros((3, )), np.identity(3)) self.ax.add_collection(self.polyc)
def plot_3d(image, threshold=-300): # Position the scan upright, # so the head of the patient would be at the top facing the camera p = image.transpose(2, 1, 0) verts, faces = measure.marching_cubes(p, threshold) fig = plt.figure(figsize=(10, 10)) ax = fig.add_subplot(111, projection='3d') # Fancy indexing: `verts[faces]` to generate a collection of triangles mesh = art3d.Poly3DCollection(verts[faces], alpha=0.1) face_color = [0.5, 0.5, 1] mesh.set_facecolor(face_color) ax.add_collection3d(mesh) ax.set_xlim(0, p.shape[0]) ax.set_ylim(0, p.shape[1]) ax.set_zlim(0, p.shape[2]) plt.show()
def generate_face(location, color1, axis1, direction1): x_face = [[0, 0, 0], [0, 0, 1], [0, 1, 1], [0, 1, 0]] y_face = [[0, 0, 0], [1, 0, 0], [1, 0, 1], [0, 0, 1]] z_face = [[0, 0, 0], [1, 0, 0], [1, 1, 0], [0, 1, 0]] faces = [x_face, y_face, z_face] face = faces[axis1] for row in face: if direction1 == 1: row[axis1] += 1 for i in range(3): row[i] += location[i] face_nump = np.array(face) side = art3d.Poly3DCollection([face_nump]) side.set_edgecolor('k') side.set_facecolor(color1) collection.append(side)
def ShowStlModel(self,): # Using an existing stl file: try: hand_mesh = mesh.Mesh.from_file('MeshedReconstruction.stl') self.b.cla() # self.b.scatter(0,0,0) self.b.set_xlabel('X direction') self.b.set_ylabel('Y direction') self.b.set_title('Display STL file') self.b.set_xlim([0, 0.5]) self.b.set_ylim([-0.3, 0]) self.b.set_zlim([-0.5, -0.4]) scale = hand_mesh.points.flatten(-1) # print(scale) self.b.auto_scale_xyz(scale, scale, scale) self.b.add_collection3d(art3d.Poly3DCollection(hand_mesh.vectors)) # self.a.set_aspect('equal', 'box') self.stlPlot.draw() return hand_mesh except Exception as e: print('Cannot find any STL file to show') return
def plot_surface(self, ax, sp): """Plot all the vertices points on the received axel :param ax: Axel The axel to draw the points on :param sp: Space The colour space for computing the gamut. """ nd_data = self.data.get_linear(sp) # Creates a new ndarray with points points = self.get_vertices(nd_data) # ndarray with all the vertices x = points[:, 0] y = points[:, 1] z = points[:, 2] for i in range(self.hull.simplices.shape[0] ): # Iterates and draws all the vertices points tri = art3d.Poly3DCollection( [self.hull.points[self.hull.simplices[i]]]) ax.add_collection(tri) # Adds created points to the ax ax.set_xlim([0, 10]) # Set the limits for the plot manually ax.set_ylim([-10, 10]) ax.set_zlim([-10, 10]) plt.show()
def draw(list_points, poly, title): fig = plt.figure() ax = Axes3D(fig) xlim = [0, 1] ylim = [0, 1] zlim = [0, 1] for j, points in enumerate(list_points): xlim = [ min(np.min(points[:, 0]) - 2, xlim[0]), max(xlim[1], np.max(points[:, 0]) + 2) ] ylim = [ min(np.min(points[:, 1]) - 2, ylim[0]), max(ylim[1], np.max(points[:, 1]) + 2) ] zlim = [ min(np.min(points[:, 2]) - 2, zlim[0]), max(zlim[1], np.max(points[:, 2]) + 2) ] for pp in poly: p = art3d.Poly3DCollection([points[pp, :]]) p.set_color(col[j]) p.set_edgecolor(edge_col[j]) ax.add_collection3d(p) left = min(xlim[0], ylim[0], zlim[0]) right = max(xlim[1], ylim[1], zlim[1]) ax.set_xlim3d(left, right) ax.set_ylim3d(left, right) ax.set_zlim3d(left, right) ax.set_aspect('equal') plt.title(title) plt.show()
def create_polygon(zipped_list, ax, dict_color): lst_pt = zipped_list[0] color = np.random.rand( 3, ) if (not zipped_list[1]) else dict_color[zipped_list[1]] if (len(lst_pt) == 1): list_solo_x, list_solo_y, list_solo_z = [lst_pt[0][0] ], [lst_pt[0][1] ], [lst_pt[0][2]] ax.plot(list_solo_x, list_solo_y, list_solo_z, marker='o', linestyle="none", color=color) elif (len(lst_pt) == 2): ax.add_collection3d(art3d.Line3DCollection([lst_pt], color=color)) else: ax.add_collection3d( art3d.Poly3DCollection([lst_pt], facecolors=color, edgecolors="black", linewidths=1, linestyle="-", alpha=0.5))
def add_polygon_3d(self, points=[], poly_id="undefined", ax=None, **kwargs): """Add a polygon specified by list of input points :param list points: list with :class:`GeoPoint` objects :param str poly_id: string ID of this object (e.g. for deletion, default: "undefined") """ if ax is None: ax = self.ax if not "label" in kwargs: kwargs["label"] = poly_id xs, ys, zs = [], [], [] for p in points: x, y = self(p.longitude, p.latitude) xs.append(x) ys.append(y) zs.append(p.altitude) #*1000) coords = [list(zip(xs, ys, zs))] poly_coll = a3d.Poly3DCollection(coords, **kwargs) ax.add_collection3d(poly_coll)