def sphere_scatter3d(writer, data, output, meta, tag='sphere'): data = norm_range(data) out = output[0].cpu().detach().clone() out0 = out[0][0:3] out1 = out[1][0:3] stride = data.shape[2] // out.shape[2] im0 = data[0][:, ::stride, ::stride] x0 = out0[0].reshape(-1) y0 = out0[1].reshape(-1) z0 = out0[2].reshape(-1) c0 = im0.permute(1, 2, 0).reshape(-1, 3) im1 = data[1][:, ::stride, ::stride] x1 = out1[0].reshape(-1) y1 = out1[1].reshape(-1) z1 = out1[2].reshape(-1) c1 = im1.permute(1, 2, 0).reshape(-1, 3) axmin = np.round(out.min()) axmax = np.round(out.max()) fig = plt.figure() ax = mplot3d.Axes3D(fig) ax.set_xlim(axmin, axmax) ax.set_ylim(axmin, axmax) ax.set_zlim(axmin, axmax) ax.scatter3D(x0, y0, z0, c=c0.numpy(), s=40, linewidths=0, depthshade=False) writer.add_figure(tag + '/0', fig) fig = plt.figure() ax = mplot3d.Axes3D(fig) ax.set_xlim(axmin, axmax) ax.set_ylim(axmin, axmax) ax.set_zlim(axmin, axmax) ax.scatter3D(x1, y1, z1, c=c1.numpy(), s=40, linewidths=0, depthshade=False) writer.add_figure(tag + '/1', fig)
def plot_mesh(points, tris, centroids, normals, quivers=False): fig = plt.figure(figsize=(8, 8)) ax = mplot3d.Axes3D(fig) if quivers: x, y, z = centroids u, v, w = normals.T ax.quiver(x, y, z, u, v, w, length=0.2, normalize=True) meshvectors = mesh_vectors(points, tris) ax.add_collection3d( mplot3d.art3d.Poly3DCollection(meshvectors, facecolor=[0.5, 0.5, 0.5], lw=0.5, edgecolor=[0, 0, 0], alpha=.8, antialiaseds=True)) scale = points.flatten('F') ax.auto_scale_xyz(scale, scale, scale) ax.set_xlabel('x') ax.set_ylabel('y') ax.set_zlabel('z') plt.show() return fig
def visualize(pymesh_mesh=None, save_path=None): # Create a new plot figure = plt.figure() axes = mplot3d.Axes3D(figure) from stl import mesh as npmesh def convert_pymesh_to_npmesh(pymesh_mesh): vertices = pymesh_mesh.vertices faces = pymesh_mesh.faces mesh_np = npmesh.Mesh(np.zeros(faces.shape[0], dtype=npmesh.Mesh.dtype)) for count, face in enumerate(faces): for axis in range(3): mesh_np.vectors[count][axis] = vertices[face[axis], :] return mesh_np # Load the STL files and add the vectors to the plot your_mesh = convert_pymesh_to_npmesh(pymesh_mesh) axes.add_collection3d(mplot3d.art3d.Poly3DCollection(your_mesh.vectors)) # Auto scale to the mesh size scale = your_mesh.points.flatten(-1) axes.auto_scale_xyz(scale, scale, scale) axes.view_init(0, -180) # Save plot as name 'path' plt.savefig(save_path) return
def generateAxes(self): ''' Produces axes for plotting surfaces and paths ''' self.fig = pyplot.figure() axes = mplot3d.Axes3D(self.fig) return axes
def plot_meshes(mesh_list=[], point_list=[], points_new_list=[]): # Optionally render the rotated cube faces import matplotlib.pyplot as plt from mpl_toolkits import mplot3d # Create a new plot figure = plt.figure() axes = mplot3d.Axes3D(figure) # Render the cube color_list = ['r', 'b', 'g'] for counter, mesh in enumerate(mesh_list): poly_3d = mplot3d.art3d.Poly3DCollection(mesh.vectors) axes.add_collection3d(poly_3d) poly_3d.set_facecolor(color_list[counter]) for point in point_list: axes.scatter([point[0]], [point[1]], [point[2]], c=[1, 0, 0], alpha=0.5) for point in points_new_list: axes.scatter([point[0]], [point[1]], [point[2]], c=[0, 1, 0], alpha=1) # Auto scale to the mesh size if len(mesh_list) > 0: scale = mesh.points.flatten(-1) axes.auto_scale_xyz(scale, scale, scale) plt.xlabel('x') plt.ylabel('y') # Show the plot to the screen plt.show()
def draw_mesh(meshname, mesh, refinement): fig = plt.figure(figsize=(6, 6), frameon=False) ax = mplot3d.Axes3D(fig) # Collect face data as vectors for plotting F = boundary_faces(tetramesh.elements) facevectors = np.zeros((F.shape[0], 3, 3)) for i, face in enumerate(F): for j in range(3): facevectors[i][j] = tetramesh.vertices[face[j], :] ax.add_collection3d( mplot3d.art3d.Poly3DCollection(facevectors, facecolor=[0.5, 0.5, 0.5], lw=0.5, edgecolor=[0, 0, 0], alpha=0.66)) scale = tetramesh.vertices.flatten() ax.auto_scale_xyz(scale, scale, scale) plt.setp(ax.get_xticklabels(), visible=False) plt.setp(ax.get_yticklabels(), visible=False) plt.setp(ax.get_zticklabels(), visible=False) plt.savefig(meshname) return
def createWorkspaceConvexHull(self): # Load the numpy array of sampled workspace end effector points print("Loading numpy array {}{}".format(self.directory, self.workspaceFilename)) points = np.load(self.directory + self.workspaceFilename) print(points.shape) # Calculate the complex hull! hull = ConvexHull(points) # create the figure # fig_workspace = plt.figure() # #add an axis # ax = fig_workspace.add_subplot(111, projection='3d') rows, cols = hull.simplices.shape # Plot surface traingulation simplical_facet_corners = [] for counter, simplex in enumerate(hull.simplices): simplical_facet_corners.append([ points[simplex[0], :], points[simplex[1], :], points[simplex[2], :] ]) # Define directory to save convex hull self.directory = '/data' self.convexHullFilename = '/EEZYbotARM_workspace/workspace_convexHull.p' with open(self.directory + self.convexHullFilename, 'wb') as fp: pickle.dump(simplical_facet_corners, fp) # Plotting preperation ax = a3.Axes3D(pl.figure()) # facetCol = sp.rand(3) #[0.0, 1.0, 0.0] facetCol = [0.5, 0.8, 0.4] lineCol = [0.8, 0.8, 0.8, 0.5] # Plot surface traingulation for simplex in hull.simplices: vtx = [ points[simplex[0], :], points[simplex[1], :], points[simplex[2], :] ] tri = a3.art3d.Poly3DCollection([vtx], linewidths=1, alpha=0.4) tri.set_color(facetCol) tri.set_edgecolor(lineCol) ax.add_collection3d(tri) # Set limits for plot ax.set_xlim([-350, 350]) ax.set_ylim([-350, 350]) ax.set_zlim([-350, 350]) # plt.axis('off') plt.show()
def draw_3D_vertices(vertices, surfaces=None, surf_color=None, ax=None): if ax is None: fig = plt.figure() ax = plt3.Axes3D(fig) if surfaces is None: surfaces = [range(len(vertices))] for i, surf in enumerate(surfaces): tri = plt3.art3d.Poly3DCollection(vertices[surf]) if surf_color is None: face_color = np.random.rand(3) else: face_color = surf_color[i] tri.set_facecolor(face_color) tri.set_edgecolor('k') ax.add_collection3d(tri) x = np.concatenate(vertices[:, :, 0]) y = np.concatenate(vertices[:, :, 1]) z = np.concatenate(vertices[:, :, 2]) set_limits_3D(ax, x, y, z) plt.show() return ax
def show_stl_file(): """ STL is a file format native to the stereolithography CAD software created by 3D Systems. """ from stl import mesh from mpl_toolkits import mplot3d from matplotlib import pyplot # Create a new plot figure = pyplot.figure() axes = mplot3d.Axes3D(figure) # Load the STL files and add the vectors to the plot your_mesh = mesh.Mesh.from_file('coke.stl') axes.add_collection3d(mplot3d.art3d.Poly3DCollection(your_mesh.vectors)) # Auto scale to the mesh size scale = your_mesh.points.flatten(-1) axes.auto_scale_xyz(scale, scale, scale) # volume, cog, inertia = your_mesh.get_mass_properties() # print("Volume = {0}".format(volume)) # print("Position of the center of gravity (COG) = {0}".format(cog)) # print("Inertia matrix at expressed at the COG = {0}".format(inertia[0,:])) # print(" {0}".format(inertia[1,:])) # print(" {0}".format(inertia[2,:])) # Show the plot to the screen pyplot.show()
def plot_bad_edges(mesh, bad_indices): # Create a new plot figure = pyplot.figure() axes = mplot3d.Axes3D(figure) good_ones = np.delete(mesh.vectors, bad_indices, 0) bad_ones = [] for i in bad_indices: bad_ones.append(mesh.vectors[i]) bad_ones = np.asarray(bad_ones) mesh_collection_good = mplot3d.art3d.Poly3DCollection(good_ones) mesh_collection_good.set_facecolor((0, 1, 1)) mesh_collection_good.set_edgecolor((0, 0, 1)) axes.add_collection3d(mesh_collection_good) mesh_collection_bad = mplot3d.art3d.Poly3DCollection(bad_ones) mesh_collection_bad.set_facecolor((1, 1, 0)) mesh_collection_bad.set_edgecolor((1, 0, 0)) axes.add_collection3d(mesh_collection_bad) # Auto scale to the mesh size scale = mesh.points.flatten(-1) axes.auto_scale_xyz(scale, scale, scale) # Show the plot to the screen pyplot.show()
def main(): make_blobs(n_samples=10, centers=3, n_features=3, random_state=0) P = 10 * PSD() a = np.random.multivariate_normal([0, 0, 0], P, 100) np.save('aP', P) np.save('a', a) print(P) P = 10 * PSD() b = np.random.multivariate_normal([10, 10, 10], P, 100) np.save('bP', P) np.save('b', b) print(P) P = 10 * PSD() c = np.random.multivariate_normal([-10, -10, 10], P, 100) np.save('cP', P) np.save('c', c) print(P) figure = plt.figure() axis = mplot3d.Axes3D(figure) axis.scatter(a[:, 0], a[:, 1], a[:, 2], marker='+') axis.scatter(b[:, 0], b[:, 1], b[:, 2], marker='o') axis.scatter(c[:, 0], c[:, 1], c[:, 2], marker='*') plt.show()
def plot2(self, img, index=2, fourierlines=False, title="none"): """For testing purposes""" import matplotlib.pyplot as plt fig = plt.figure(index) if 0: import mpl_toolkits.mplot3d as p3 ax = p3.Axes3D(fig) yy, xx = np.indices(img.shape) ax.plot_surface(yy, xx, img) else: ax = fig.add_subplot(111) if img.size in img.shape: x = ft.fftfreq(len(img), 1, centered=True) ax.plot(x, img) else: ax.imshow(img, origin="lower", interpolation="nearest") if fourierlines: s = np.asarray(img.shape) fmin, fmax = ft.fft_freqind(s) cen = -fmin ax.plot([cen[1], cen[1]], [0, s[0] - 1]) ax.plot([0, s[1] - 1], [cen[0], cen[0]]) plt.title(title) plt.pause(0.1) raw_input("press enter...")
def surface(): "show a nice 3d plot just for demo purposes" prob = FesProblem() steps = (15, 15) lower = (0.0, 0.0) upper = (1.0, 1.0) domain = [np.linspace(l, u, s) for s, l, u in zip(steps, lower, upper)] X = domain[0] Y = domain[1] L = [len(d) for d in domain] s = [] e = 1 for d in domain: L = L[1:] LS = np.prod(L) s.append(np.repeat(d.tolist() * LS, e)) if len(L) > 0: e = e * L[0] z = np.array([prob.objfun(x) for x in np.array(s).T]).T[1] z = np.reshape(z, steps) fig = plt.figure() ax = mpl.Axes3D(fig) # fig.add_subplot(111,projection='3d') ax.plot_surface(X, Y, z, rstride=1, cstride=1, cmap=cm.jet, linewidth=0) plt.show()
def plot_3d(x, y, p, label='$z$', elev=30.0, azim=45.0): """ Creates a Matplotlib figure with a 3D surface plot of the scalar field p. Parameters ---------- x : numpy.ndarray Gridline locations in the x direction as a 1D array of floats. y : numpy.ndarray Gridline locations in the y direction as a 1D array of floats. p : numpy.ndarray Scalar field to plot as a 2D array of floats. label : string, optional Axis label to use in the third direction; default: 'z'. elev : float, optional Elevation angle in the z plane; default: 30.0. azim : float, optional Azimuth angle in the x,y plane; default: 45.0. """ fig = pyplot.figure(figsize=(8.0, 6.0)) ax = mplot3d.Axes3D(fig) ax.set_xlabel('$x$') ax.set_ylabel('$y$') ax.set_zlabel(label) X, Y = numpy.meshgrid(x, y) ax.plot_surface(X, Y, p, cmap=cm.viridis) ax.set_xlim(x[0], x[-1]) ax.set_ylim(y[0], y[-1]) ax.view_init(elev=elev, azim=azim)
def draw_mesh(mesh): fig = plt.figure(figsize=(6, 6), frameon=False) ax = mplot3d.Axes3D(fig) # Collect face data as vectors for plotting F = mesh.elements P = mesh.nodes T = mesh.elements facevectors = np.zeros((F.shape[0], 3, 3)) for i, face in enumerate(F): for j in range(3): facevectors[i][j] = mesh.vertices[face[j], :] ax.add_collection3d( mplot3d.art3d.Poly3DCollection(facevectors, facecolor=[0.5, 0.5, 0.5], lw=0.5, edgecolor=[0, 0, 0], alpha=0.66)) scale = mesh.vertices.flatten() I = trimesh.Trimesh(vertices=P, faces=T, process=False).moment_inertia Ip, Q = trimesh.inertia.principal_axis(I) ax.quiver(0, 0, 0, Q[2, 0], Q[2, 1], Q[2, 2], length=20, normalize=False) ax.quiver(15, 10, -10, 0, 0, 20, length=1, normalize=False, color='k') ax.auto_scale_xyz(scale, scale, scale) plt.show() return fig
def __init__(self, **kwargs): self.file_name = kwargs.pop('file_name', None) multi_body = np.array(kwargs.pop('multi_body', False)) self.debug = kwargs.pop('debug', False) if (multi_body and self.file_name is not None): self.read_geometry_file() sec_time = timer.time() print('Processing Geometries...') sys.stdout.flush() self.isol_geom() print('Done ', timer.time() - sec_time, 'sec') print(np.size(self.objects, 0), 'solids identified') if (self.debug): # debugging plot figure = plt.figure() axes = mplot3d.Axes3D(figure) for object_mesh in self.objects: axes.add_collection3d( mplot3d.art3d.Poly3DCollection(object_mesh)) scale = self.object_mesh.points.flatten(-1) axes.set_aspect('equal') axes.set_xlabel('x') axes.set_ylabel('y') axes.set_zlabel('z') axes.auto_scale_xyz(scale, scale, scale) plt.show()
def line3Dregress(self, x, y, z, show=False): data = np.concatenate( (x[:, np.newaxis], y[:, np.newaxis], z[:, np.newaxis]), axis=1) datamean = data.mean(axis=0) uu, dd, vv = np.linalg.svd(data - datamean) x0, y0, z0 = vv[0] v = np.array((z0, z0 * y0 / x0, -x0 - y0 * y0 / x0)) v /= np.linalg.norm(v) if show: linepts = vv[0] * np.mgrid[-7:7:2j][:, np.newaxis] linepts += datamean linepts1 = v * np.mgrid[-7:7:2j][:, np.newaxis] linepts1 += datamean import matplotlib.pyplot as plt import mpl_toolkits.mplot3d as m3d ax = m3d.Axes3D(plt.figure()) ax.scatter3D(*data.T) ax.plot3D(*linepts.T) ax.plot3D(*linepts1.T) plt.show() return v
def plot(self, plot_file=None, save_fig=False): """ Method to plot an stl file. If `plot_file` is not given it plots `self.infile`. :param string plot_file: the stl filename you want to plot. :param bool save_fig: a flag to save the figure in png or not. If True the plot is not shown. """ if plot_file is None: plot_file = self.infile else: self._check_filename_type(plot_file) # Create a new plot figure = pyplot.figure() axes = mplot3d.Axes3D(figure) # Load the STL files and add the vectors to the plot stl_mesh = mesh.Mesh.from_file(plot_file) axes.add_collection3d(mplot3d.art3d.Poly3DCollection(stl_mesh.vectors)) # Auto scale to the mesh size scale = stl_mesh.points.flatten(-1) axes.auto_scale_xyz(scale, scale, scale) # Show the plot to the screen if not save_fig: pyplot.show() else: figure.savefig(plot_file.split('.')[0] + '.png')
def plotSurf(surf, points): ax = a3.Axes3D(pl.figure()) for t in surf: vtx = t.getTri() print vtx tri = a3.art3d.Poly3DCollection([vtx]) tri.set_color(colors.rgb2hex(np.random.rand(3))) tri.set_edgecolor('k') ax.add_collection3d(tri) x = [] y = [] z = [] for p in points: x.append(p[0]) y.append(p[1]) z.append(p[2]) ax.scatter(x, y, z) ax.set_xlim(0, 1) ax.set_ylim(0, 1) ax.set_zlim(0, 1) pl.show() del (x) del (y) del (z)
def findlongaxis(r): a = r.mean(axis=0) uu, dd, vv = np.linalg.svd(r - a) # Now vv[0] contains the first principal component, i.e. the direction # vector of the 'best fit' line in the least squares sense. # Now generate some points along this best fit line, for plotting. # I use -7, 7 since the spread of the data is roughly 14 # and we want it to have mean 0 (like the points we did # the svd on). Also, it's a straight line, so we only need 2 points. linepts = vv[0] * np.mgrid[-7:7:2j][:, np.newaxis] # shift by the mean to get the line in the right place linepts += a # Verify that everything looks right. longaxis = np.vstack((a, a + vv[0, :] * 10)) import matplotlib.pyplot as plt import mpl_toolkits.mplot3d as m3d if 0: ax = m3d.Axes3D(plt.figure()) ax.scatter3D(*r.T) ax.plot3D(*linepts.T) plt.show() return longaxis
def plot(self, plot_file=None, save_fig=False): """ Method to plot a file. If `plot_file` is not given it plots `self.shape`. :param string plot_file: the filename you want to plot. :param bool save_fig: a flag to save the figure in png or not. If True the plot is not shown. :return: figure: matlplotlib structure for the figure of the chosen geometry :rtype: matplotlib.pyplot.figure """ if plot_file is None: shape = self.shape plot_file = self.infile else: shape = self.load_shape_from_file(plot_file) stl_writer = StlAPI_Writer() # Do not switch SetASCIIMode() from False to True. stl_writer.SetASCIIMode(False) stl_writer.Write(shape, 'aux_figure.stl') # Create a new plot figure = pyplot.figure() axes = mplot3d.Axes3D(figure) # Load the STL files and add the vectors to the plot stl_mesh = mesh.Mesh.from_file('aux_figure.stl') os.remove('aux_figure.stl') axes.add_collection3d( mplot3d.art3d.Poly3DCollection(stl_mesh.vectors / 1000)) # Get the limits of the axis and center the geometry max_dim = np.array([\ np.max(stl_mesh.vectors[:, :, 0]) / 1000,\ np.max(stl_mesh.vectors[:, :, 1]) / 1000,\ np.max(stl_mesh.vectors[:, :, 2]) / 1000]) min_dim = np.array([\ np.min(stl_mesh.vectors[:, :, 0]) / 1000,\ np.min(stl_mesh.vectors[:, :, 1]) / 1000,\ np.min(stl_mesh.vectors[:, :, 2]) / 1000]) max_lenght = np.max(max_dim - min_dim) axes.set_xlim(\ -.6 * max_lenght + (max_dim[0] + min_dim[0]) / 2,\ .6 * max_lenght + (max_dim[0] + min_dim[0]) / 2) axes.set_ylim(\ -.6 * max_lenght + (max_dim[1] + min_dim[1]) / 2,\ .6 * max_lenght + (max_dim[1] + min_dim[1]) / 2) axes.set_zlim(\ -.6 * max_lenght + (max_dim[2] + min_dim[2]) / 2,\ .6 * max_lenght + (max_dim[2] + min_dim[2]) / 2) # Show the plot to the screen if not save_fig: pyplot.show() else: figure.savefig(plot_file.split('.')[0] + '.png') return figure
def plotMesh(mesh, points=None): # Create a new plot figure = pyplot.figure() axes = mplot3d.Axes3D(figure) toPlot = stlmesh.Mesh( np.zeros(mesh.faces.shape[0], dtype=stlmesh.Mesh.dtype)) for i, f in enumerate(mesh.faces): for j in range(3): toPlot.vectors[i][j] = mesh.vertices[f[j], :] axes.add_collection3d(mplot3d.art3d.Poly3DCollection(toPlot.vectors)) if not (points is None) and points.any(): axes.scatter3D(points[:, 0], points[:, 1], zs=points[:, 2], c='r', s=20) # Auto scale to the mesh size scale = toPlot.points.flatten(-1) axes.auto_scale_xyz(scale, scale, scale) # Show the plot to the screen pyplot.show()
def chull_plot_3d(chull, faces, ax=None, **kwargs): """ Plot the given faces that define a convex hull in 3-D. Parameters ---------- chull : scipy.spatial.ConvexHull instance Original convex hull that we want to plot in 3-D. faces : pycoverage3d.visutils.Geom.PlanarFace instance Faces that define a convex hull in 3-D. ax : matplotlib.axes.Axes instance, optional Axes to plot on, by default None. Returns ------- fig : matplotlib.figure.Figure instance Figure corresponding to the plot. See Also -------- pycoverge3d.visutils.Geom.PlanarFace : PlanarFace class used to compute the faces. Notes ----- Requires matplotlib and mpl_toolkits. """ ax = mplt.Axes3D(plt.figure()) pc = mplt.art3d.Poly3DCollection(faces, **kwargs) ax.add_collection3d(pc) adjust_bounds(ax, chull.points) return ax.figure
def affichage_fichier_stl(lien) : figure= pyplot.figure() axes=mplot3d.Axes3D(figure) fichier=mesh.Mesh.from_file(lien) a=(fichier.vectors) normale=(fichier.normals) normale[7][0]=1 #Vecteur normal du fichié V dans le mauvais sens des x #print(a[1]) # print(len(a)) # print(CalculForce(a,normale,0)) #Dans l'outil fichier # print(CalculForce(a,normale,-2)) # print(CalculForce(a,normale,-0.5)) """baisser la présicion""" #print('milieu ',Dichotomie(0,-4,0.0000001)) #print(CalculForce(a,normale,Dichotomie(0,-4,0.0000001))) """Problème pour le fichier Mini_650 te V avec les vecteurs normaux""" outil.translation(2,a,(outil.Dichotomie(400,-400,0.00001,a,normale,Rho=1000,masse=346618700000,potentiometre=0))[0]) axes.add_collection3d(mplot3d.art3d.Poly3DCollection(fichier.vectors)) scale = fichier.points.flatten() axes.auto_scale_xyz(scale, scale, scale) pyplot.show()
def start_simulation(self): self.setFixedSize(1000, 500) self.button_1.hide() self.button_2 = QPushButton("Exit") self.layout.addWidget(self.button_2, 8, 8, 1, 1) self.button_2.clicked.connect(self.exit) #Graphique self.fig2 = plt.figure() self.graph = FigureCanvas(self.fig2) plt.plot([1, 2, 3, 4]) plt.xlabel('Calcul de la position du tirant d\'eau') self.graph.draw() self.layout.addWidget(self.graph, 2, 5, 4, 4) #Figure 3D self.fig = plt.figure() self.canvas = FigureCanvas(self.fig) axes = mplot3d.Axes3D(self.fig) your_mesh = mesh.Mesh.from_file(self.coque) axes.add_collection3d(mplot3d.art3d.Poly3DCollection( your_mesh.vectors)) scale = your_mesh.points.flatten("C") axes.auto_scale_xyz(scale, scale, scale) self.canvas.draw() self.layout.addWidget(self.canvas, 2, 0, 4, 4)
def plot_panels(self, X_str, elev=25, azim=-160, edge_color='k', fill_color=1, transp=0.2, ax=None): m, n, bp = self.m, self.n, self.bp X_coord = self.X if X_str == 'X' else self.XV X = X_coord[:, :, :, 0] Y = X_coord[:, :, :, 1] Z = X_coord[:, :, :, 2] new_ax = not ax if new_ax: ax = a3.Axes3D(plt.figure()) for i in range(m): for j in range(n): vtx = np.array([X[i, j], Y[i, j], Z[i, j]]).T panel = a3.art3d.Poly3DCollection([vtx]) panel.set_facecolor((0, 0, fill_color, transp)) panel.set_edgecolor(edge_color) ax.add_collection3d(panel) if new_ax: limits = (-bp / 1.8, bp / 1.8) ax.set_xlim(limits) ax.set_ylim(limits) ax.set_zlim(limits) ax.set_xlabel('x') ax.set_ylabel('y') ax.set_zlabel('z') ax.view_init(elev=elev, azim=azim) return ax
def plot_model(face_collection): # Create new empty plot fig = plt.figure() axes = mplot3d.Axes3D(fig) axes.set_xlabel("X axis") axes.set_ylabel("Y axis") axes.set_zlabel("Z axis") # Add vectors from models to plot good_collection = mplot3d.art3d.Poly3DCollection( face_collection.get_vertices(vtype="good")) good_collection.set_edgecolor('black') # Wireframe good_collection.set_facecolor('green') bad_collection = mplot3d.art3d.Poly3DCollection( face_collection.get_vertices(vtype="bad")) bad_collection.set_edgecolor('black') # Wireframe bad_collection.set_facecolor('red') axes.add_collection3d(good_collection) axes.add_collection3d(bad_collection) # Plot points #axes.scatter3D(model.x,model.y,model.z,color='yellow', s=1) # plot vertices # Display plot plt.show()
def plotMesh(self, use_displacement: bool = True, edge_color: str = None, alpha: float = 0.2): import mpl_toolkits.mplot3d as a3 import matplotlib.pyplot as plt from matplotlib import _pylab_helpers if _pylab_helpers.Gcf.get_active() is None: axes = a3.Axes3D(plt.figure()) else: axes = plt.gca() if use_displacement: points = self.R + self.U if edge_color is None: edge_color = "red" else: points = self.R if edge_color is None: edge_color = "blue" vts = points[self.T, :] helper = np.array([[0, 1], [0, 2], [0, 3], [1, 2], [1, 3], [2, 3]]) tri = a3.art3d.Line3DCollection(vts[:, helper].reshape(-1, 2, 3)) tri.set_alpha(alpha) tri.set_edgecolor(edge_color) axes.add_collection3d(tri) axes.plot(points[:, 0], points[:, 1], points[:, 2], 'ko') axes.set_aspect('equal')
def plot_polytope_3d(A, b, ax=None, color='red', trans=0.2): verts = np.array(ppm.compute_polytope_vertices(A, b)) # compute the triangles that make up the convex hull of the data points hull = ConvexHull(verts) triangles = [verts[s] for s in hull.simplices] # combine co-planar triangles into a single face faces = Faces(triangles, sig_dig=1).simplify() # plot if ax == None: ax = a3.Axes3D(plt.figure()) pc = a3.art3d.Poly3DCollection(faces, facecolor=color, edgecolor="k", alpha=trans) ax.add_collection3d(pc) # define view yllim, ytlim = ax.get_ylim() xllim, xtlim = ax.get_xlim() zllim, ztlim = ax.get_zlim() x = verts[:, 0] x = np.append(x, [xllim, xtlim]) y = verts[:, 1] y = np.append(y, [yllim, ytlim]) z = verts[:, 2] z = np.append(z, [zllim, ztlim]) ax.set_xlim(np.min(x) - 1, np.max(x) + 1) ax.set_ylim(np.min(y) - 1, np.max(y) + 1) ax.set_zlim(np.min(z) - 1, np.max(z) + 1)
def plot_mesh(mesh): """ Load and plot initial """ figure = plt.figure() axes = mplot3d.Axes3D(figure) if mesh[0].shape[0] == 9: axes.add_collection3d( mplot3d.art3d.Poly3DCollection(mesh.vectors, linewidths=1, alpha=0.01)) axes.add_collection3d( mplot3d.art3d.Line3DCollection(mesh.vectors, colors='k', linewidths=0.2, linestyles=':')) scale = mesh.points.flatten('C') if mesh[0].shape[0] == 3: axes.add_collection3d( mplot3d.art3d.Poly3DCollection(mesh, linewidths=1, alpha=0.5)) axes.add_collection3d( mplot3d.art3d.Line3DCollection(mesh, colors='k', linewidths=0.2, linestyles=':')) scale = mesh.flatten('C') axes.auto_scale_xyz(scale, scale, scale) plt.show()