def mixed_type_ug(): """A slightly more complex example of how to generate an unstructured grid with different cell types. Returns a created unstructured grid. """ points = array([[0,0,0], [1,0,0], [0,1,0], [0,0,1], # tetra [2,0,0], [3,0,0], [3,1,0], [2,1,0], [2,0,1], [3,0,1], [3,1,1], [2,1,1], # Hex ], 'f') # shift the points so we can show both. points[:,1] += 2.0 # The cells cells = array([4, 0, 1, 2, 3, # tetra 8, 4, 5, 6, 7, 8, 9, 10, 11 # hex ]) # The offsets for the cells, i.e. the indices where the cells # start. offset = array([0, 5]) tetra_type = tvtk.Tetra().cell_type # VTK_TETRA == 10 hex_type = tvtk.Hexahedron().cell_type # VTK_HEXAHEDRON == 12 cell_types = array([tetra_type, hex_type]) # Create the array of cells unambiguously. cell_array = tvtk.CellArray() cell_array.set_cells(2, cells) # Now create the UG. ug = tvtk.UnstructuredGrid(points=points) # Now just set the cell types and reuse the ug locations and cells. ug.set_cells(cell_types, offset, cell_array) return ug
def make_data(): points = N.array([[0,0,0], [1,0,0], [0,1,0], [0,0,1], # tets [1,0,0], [2,0,0], [1,1,0], [1,0,1], [2,0,0], [3,0,0], [2,1,0], [2,0,1], ], 'f') tets = N.array([[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11]]) tet_type = tvtk.Tetra().cell_type ug = tvtk.UnstructuredGrid(points=points) ug.set_cells(tet_type, tets) # Setup the point attributes. temp = N.random.random(12) v = N.random.randn(12, 3) ten = N.random.randn(12, 9) a = tvtk.FloatArray(name='p') a.from_array(N.random.randn(12)) ug.point_data.add_array(a) ug.point_data.scalars = temp ug.point_data.scalars.name = 't' ug.point_data.vectors = v ug.point_data.vectors.name = 'v' ug.point_data.tensors = ten ug.point_data.tensors.name = 'ten' # Setup the cell attributes. temp = N.random.random(3) v = N.random.randn(3, 3) ten = N.random.randn(3, 9) ug.cell_data.scalars = temp ug.cell_data.scalars.name = 't' ug.cell_data.vectors = v ug.cell_data.vectors.name = 'v' ug.cell_data.tensors = ten ug.cell_data.tensors.name = 'ten' return ug
def get_complete_structure(tetrahedrons): """ Visualize the complete tetrahedron mesh of all regions of the tetrahedron mesh :param tetrahedrons: list of tetrahedrons (of type Tetrahedron) :return: data for mayavi data source """ vertices = list() tets = list() index = 0 for tetrahedron in tetrahedrons: tet_vertices_indices = [] for i in range(4): v = tetrahedron.get_vertex(i) vertices.append([v.x, v.y, v.z]) tet_vertices_indices.append(index) index += 1 tets.append(tet_vertices_indices) vertices = np.array(vertices) tets = np.array(tets) tet_type = tvtk.Tetra().cell_type unstructured_grid = tvtk.UnstructuredGrid(points=vertices) unstructured_grid.set_cells(tet_type, tets) return unstructured_grid
def single_type_ug(): """Simple example showing how to create an unstructured grid consisting of cells of a single type. """ points = array( [ [0, 0, 0], [1, 0, 0], [0, 1, 0], [0, 0, 1], # tets [1, 0, 0], [2, 0, 0], [1, 1, 0], [1, 0, 1], [2, 0, 0], [3, 0, 0], [2, 1, 0], [2, 0, 1], ], 'f') tets = array([[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11]]) tet_type = tvtk.Tetra().cell_type ug = tvtk.UnstructuredGrid(points=points) ug.set_cells(tet_type, tets) return ug
def unstructured_grid(): points = array( [ [0, 1.2, 0.6], [1, 0, 0], [0, 1, 0], [1, 1, 1], # tetra [1, 0, -0.5], [2, 0, 0], [2, 1.5, 0], [0, 1, 0], [1, 0, 0], [1.5, -0.2, 1], [1.6, 1, 1.5], [1, 1, 1], # Hex ], 'f') # The cells cells = array([ 4, 0, 1, 2, 3, # tetra 8, 4, 5, 6, 7, 8, 9, 10, 11 # hex ]) # The offsets for the cells, i.e. the indices where the cells # start. offset = array([0, 5]) tetra_type = tvtk.Tetra().cell_type # VTK_TETRA == 10 hex_type = tvtk.Hexahedron().cell_type # VTK_HEXAHEDRON == 12 cell_types = array([tetra_type, hex_type]) # Create the array of cells unambiguously. cell_array = tvtk.CellArray() cell_array.set_cells(2, cells) # Now create the UG. ug = tvtk.UnstructuredGrid(points=points) # Now just set the cell types and reuse the ug locations and cells. ug.set_cells(cell_types, offset, cell_array) scalars = random.random(points.shape[0]) ug.point_data.scalars = scalars ug.point_data.scalars.name = 'scalars' return ug
def write_vtk_mesh(mesh, fileName): node = mesh.entity('node') GD = mesh.geo_dimension() if GD == 2: node = np.concatenate( (node, np.zeros((node.shape[0], 1), dtype=mesh.ftype)), axis=1) ug = tvtk.UnstructuredGrid(points=node) if mesh.meshtype is 'hex': cell_type = tvtk.Hexahedron().cell_type cell = mesh.ds.cell elif mesh.meshtype is 'tri': cell_type = tvtk.Triangle().cell_type cell = mesh.ds.cell for key, value in mesh.cellData.items(): i = ug.cell_data.add_array(value) ug.cell_data.get_array(i).name = key for key, value in mesh.pointData.items(): i = ug.point_data.add_array(value) ug.point_data.get_array(i).name = key elif mesh.meshtype is 'polyhedron': cell_type = tvtk.Polygon().cell_type NF, faces = mesh.to_vtk() cell = tvtk.CellArray() cell.set_cells(NF, faces) elif mesh.meshtype is 'polygon': cell_type = tvtk.Polygon().cell_type NC, cells = mesh.to_vtk() cell = tvtk.CellArray() cell.set_cells(NC, cells) elif mesh.meshtype is 'tet': cell_type = tvtk.Tetra().cell_type cell = mesh.ds.cell for key, value in mesh.cellData.items(): i = ug.cell_data.add_array(value) ug.cell_data.get_array(i).name = key for key, value in mesh.pointData.items(): i = ug.point_data.add_array(value) ug.point_data.get_array(i).name = key ug.set_cells(cell_type, cell) write_data(ug, fileName)
def write_vtk_mesh(mesh, fileName): point = mesh.point if point.shape[1] == 2: point = np.concatenate( (point, np.zeros((point.shape[0], 1), dtype=np.float)), axis=1) ug = tvtk.UnstructuredGrid(points=point) if mesh.meshtype is 'hex': cell_type = tvtk.Hexahedron().cell_type cell = mesh.ds.cell elif mesh.meshtype is 'tri': cell_type = tvtk.Triangle().cell_type cell = mesh.ds.cell for key, value in mesh.cellData.items(): i = ug.cell_data.add_array(value) ug.cell_data.get_array(i).name = key for key, value in mesh.pointData.items(): i = ug.point_data.add_array(value) ug.point_data.get_array(i).name = key elif mesh.meshtype is 'polyhedron': cell_type = tvtk.Polygon().cell_type NF, faces = mesh.to_vtk() cell = tvtk.CellArray() cell.set_cells(NF, faces) ug.cell_data.scalars = mesh.cellData['flag'] elif mesh.meshtype is 'polygon': cell_type = tvtk.Polygon().cell_type NC, cells = mesh.to_vtk() cell = tvtk.CellArray() cell.set_cells(NC, cells) elif mesh.meshtype is 'tet': cell_type = tvtk.Tetra().cell_type cell = mesh.ds.cell for key, value in mesh.cellData.items(): i = ug.cell_data.add_array(value) ug.cell_data.get_array(i).name = key for key, value in mesh.pointData.items(): i = ug.point_data.add_array(value) ug.point_data.get_array(i).name = key ug.set_cells(cell_type, cell) write_data(ug, fileName)
def _readData(self): from tvtk.api import tvtk import h5py import numpy filename = "output/%s_%s.h5" % (cell, resolution) h5 = h5py.File(filename, 'r', driver="sec2") elastThick = 40.0e+3 eqslip = 4.0 cells = h5['topology/cells'][:] (ncells, ncorners) = cells.shape vertices = h5['geometry/vertices'][:] / elastThick (nvertices, spaceDim) = vertices.shape disp = h5['vertex_fields/displacement'][tindex, :, :] / eqslip h5.close() if cell == "tet4": assert (spaceDim == 3) assert (ncorners == 4) cellType = tvtk.Tetra().cell_type elif cell == "hex8": assert (spaceDim == 3) assert (ncorners == 8) cellType = tvtk.Hexahedron().cell_type else: raise ValueError("Unknown cell '%s'." % cell) if (resolution != "6.7km" and resolution != "20km"): raise ValueError("Unavailable resolution '%s'." % resolution) data = tvtk.UnstructuredGrid() data.points = vertices data.set_cells(cellType, cells) data.point_data.vectors = disp data.point_data.vectors.name = "Displacement [m]" return data
def View(self, engine="mpl", **kwargs): """ Plots the mesh in a figure. Supports 2D and 3D mesh with two visualization backends. Call signature ::\n Tmesh.View() - engine: - `mpl` to use a matplotlib as 2D and 3D scatter plotting backend - `myv` (default) to use Mayavi for 2D and 3D mesh rendering (using `tvtk`) - kwargs: - if 'engine' argument is set to `mpl` then Matplotlib's keywords are used: - linestyle or ls : '-' , '--' , '-.' ... - linewidth or lw float value in points - marker: 'x' , 'o' , 'v' ... - color: 'r' (red), 'k' (black) , 'b' (blue) ... - [check url: http://matplotlib.org/1.3.1/api/artist_api.html#module-matplotlib.lines] \n\n - if 'engine' argument is set to "myv" then Mayavi's keywords are used: - color: the color of the vtk object. Overides the colormap, if any, when specified. This is specified as a triplet of float ranging from 0 to 1, eg (1, 1, 1) for white. - colormap: type of colormap to use. - extent: [xmin, xmax, ymin, ymax, zmin, zmax] Default is the x, y, z arrays extent. Use this to change the extent of the object created. """ dim = self.dimNode nb_points_real = self.GetNumberOfPoints() nb_points = nb_points_real + 1 # the fictitious node of index 0 and coordinates [0,0] ### a dict constructor is necessary so that the class's member ### dictionary wont be affected when fictitious triangles are suppressed real_elements_dict = dict(self.elements_dict) # the 'enumerate' function is really nice ! for i, connec_list in enumerate(real_elements_dict.values()): if 0 in connec_list: del real_elements_dict[i + 1] # i+1 because enumerate starts at 0 while my dict starts at 1 # The lists have to be cast into numpy arrays before using the TRI plot points = np.asarray(self.nodes_dict.values()) simplexes = np.asarray(real_elements_dict.values()) # Extracting columns x = points[:, 0] y = points[:, 1] if dim == 2: # points_2d is used in mayavi rendering points_2d = np.column_stack([points, np.zeros((nb_points, 1))]) elif dim == 3: # z is used in matplotlib rendering z = points[:, 2] # points_3d is used in mayavi rendering points_3d = points if engine == "mpl": if dim == 2: plt.figure() plt.gca().set_aspect('equal') plt.triplot(x, y, simplexes, **kwargs) plt.title('Mesh') plt.show() elif dim == 3: # TODO: add line connection between scattered points fig = plt.figure() ax = fig.add_subplot(111, projection='3d', aspect='equal') ax.scatter3D(x, y, z, **kwargs) ax.set_xlabel('X Label') ax.set_ylabel('Y Label') ax.set_zlabel('Z Label') plt.axis() plt.show() elif engine == "myv": if dim == 2: #this way works # z = np.zeros_like(x) # triangles = [] # for trigl in real_elements_dict.values(): triangles.append(tuple(trigl)) # ml.triangular_mesh(x, y, z, triangles, representation = 'wireframe') #another way simplex_type = 5 # = 10 for tetrahedron ug = tvtk.UnstructuredGrid(points=points_2d) if dim == 3: simplex_type = tvtk.Tetra().cell_type # = 10 for tetrahedron ug = tvtk.UnstructuredGrid(points=points_3d) ug.set_cells(simplex_type, simplexes) fig = ml.figure(bgcolor=(1, 1, 1), fgcolor=(0, 0, 0), figure=ug.class_name[3:]) surf = ml.pipeline.surface(ug, opacity=0.01) RGB = (0, 0, 0.5) #edge_color = tuple(i/255 for i in RGB) ml.pipeline.surface(ml.pipeline.extract_edges(surf), color=RGB)
6, 7, 8, 9, 10, 11, # hex 3, 3, 1, 5 ]) # The offsets for the cells, i.e. the indices where the cells # start. # offset = np.array([0, 5, 14]) offset = np.array([0, 5, 14]) tetra_type = tvtk.Tetra().cell_type # VTK_TETRA == 10 hex_type = tvtk.Hexahedron().cell_type # VTK_HEXAHEDRON == 12 cell_types = np.array([tetra_type, hex_type, 5]) # Create the array of cells unambiguously. cell_array = tvtk.CellArray() cell_array.set_cells(3, cells) print('cell_array') print(cell_array) # Now create the UG. ug = tvtk.UnstructuredGrid(points=surf_points) # Now just set the cell types and reuse the ug locations and cells. ug.set_cells(cell_types, offset, cell_array) mlab.pipeline.surface(ug) # mlab.show() mlab.show()