def quadsActor(bounds, color): """Create solid, axis-aligned quads at 0 in Z. Args: bounds: [[[xmin, ymin], [xmax, ymax]], ...] color: [R, G, B, A] """ points = vtk.vtkPoints() quads = vtk.vtkCellArray() colors = vtk.vtkUnsignedCharArray() colors.SetNumberOfComponents(4) for (index, bound) in enumerate(bounds): colors.InsertNextTuple4(*color) (low, high) = bound points.InsertNextPoint(low[0], low[1], 0) points.InsertNextPoint(high[0], low[1], 0) points.InsertNextPoint(high[0], high[1], 0) points.InsertNextPoint(low[0], high[1], 0) quad = vtk.vtkQuad() for i in range(4): quad.GetPointIds().SetId(i, 4 * index + i) quads.InsertNextCell(quad) poly_data = vtk.vtkPolyData() poly_data.SetPoints(points) poly_data.SetPolys(quads) poly_data.GetCellData().SetScalars(colors) mapper = vtk.vtkPolyDataMapper() set_mapper_input(mapper, poly_data) actor = vtk.vtkActor() actor.SetMapper(mapper) actor.RotateZ(180) actor.RotateY(180) return actor
def unstructuredgrid( self, points, npars=None ): """add unstructured grid""" points = _nansplit( points ) #assert isinstance( points, (list,tuple,numpy.ndarray) ), 'Expected list of point arrays' import vtk vtkPoints = vtk.vtkPoints() vtkPoints.SetNumberOfPoints( sum(pts.shape[0] for pts in points) ) cnt = 0 for pts in points: np, ndims = pts.shape if not npars: npars = ndims vtkelem = None if np == 2: vtkelem = vtk.vtkLine() elif np == 3: vtkelem = vtk.vtkTriangle() elif np == 4: if npars == 2: vtkelem = vtk.vtkQuad() elif npars == 3: vtkelem = vtk.vtkTetra() elif np == 8: vtkelem = vtk.vtkVoxel() # TODO hexahedron for not rectilinear NOTE ordering changes! if not vtkelem: raise Exception( 'not sure what to do with cells with ndims=%d and npoints=%d' % (ndims,np) ) if ndims < 3: pts = numpy.concatenate([pts,numpy.zeros(shape=(pts.shape[0],3-ndims))],axis=1) cellpoints = vtkelem.GetPointIds() for i,point in enumerate(pts): vtkPoints .SetPoint( cnt, point ) cellpoints.SetId( i, cnt ) cnt +=1 self.vtkMesh.InsertNextCell( vtkelem.GetCellType(), cellpoints ) self.vtkMesh.SetPoints( vtkPoints )
def buildPartialVTKGrid(self, factag): #get points required for factag pointsList = self.getPointsWithFactag(factag) #create a lookup table so we can map the #cells from the global list to a local list points = vtk.vtkPoints() localIdx = 0 ptMap = {} for pt in pointsList: ptMap[int(pt)] = localIdx localIdx = localIdx + 1 p = self.mesh.coords[(pt*3):(pt*3+3)] points.InsertNextPoint(p) vtkgrid = vtk.vtkUnstructuredGrid() vtkgrid.SetPoints(points) #get elements that have desired factag felements = self.getElementsWithFactag(factag) #build the vtk elements for element in felements: type = element.getType() nodes = element.nodes if type == eTypes.TRI: cell = vtk.vtkTriangle() elif type == eTypes.QUAD: cell = vtk.vtkQuad() elif type == eTypes.TET: cell = vtk.vtkTetra() elif type == eTypes.PYRAMID: cell = vtk.vtkPyramid() elif type == eTypes.PRISM: cell = vtk.vtkWedge() #prism elif type == eTypes.HEX: cell = vtk.vtkHexahedron() else: raise # throw an exception j = 0 for n in nodes: localId = ptMap[int(n)] cell.GetPointIds().SetId(j,localId) j = j+1 vtkgrid.InsertNextCell(cell.GetCellType(), cell.GetPointIds()) return vtkgrid
def _create_tecplot_shells(self, is_quads, quads, is_tris, tris): if is_quads: elements = quads for iface, face in enumerate(quads): elem = vtkQuad() epoints = elem.GetPointIds() epoints.SetId(0, face[0]) epoints.SetId(1, face[1]) epoints.SetId(2, face[2]) epoints.SetId(3, face[3]) self.grid.InsertNextCell(elem.GetCellType(), elem.GetPointIds()) #elem.GetCellType() = 5 # vtkTriangle #break if is_tris: elements = tris for iface, face in enumerate(tris): elem = vtkTriangle() epoints = elem.GetPointIds() epoints.SetId(0, face[0]) epoints.SetId(1, face[1]) epoints.SetId(2, face[2]) self.grid.InsertNextCell(5, elem.GetPointIds()) #elem.GetCellType() = 5 # vtkTriangle
def load_point_cloud(self, points, colors=None, mesh=False): # first, generate quad mesh, if desired if mesh: mesh = vtk.vtkCellArray() if len(points.shape) != 3 or points.shape[2] != 3: raise Exception('For the meshing to work, the points array must have ' + 'the form MxNx3') for i in xrange(points.shape[0] - 1): offset = i * points.shape[1] for j in xrange(points.shape[1] - 1): quad = vtk.vtkQuad() pids = quad.GetPointIds() pids.SetNumberOfIds(4) idx = offset + j pids.SetId(0, idx) pids.SetId(1, idx + 1) pids.SetId(2, idx + points.shape[1] + 1) pids.SetId(3, idx + points.shape[1]) mesh.InsertNextCell(quad) poly_data = vtk.vtkPolyData() poly_data.SetPoints(self._convert_points_array(points)) if mesh is not False: poly_data.SetPolys(mesh) else: # no mesh data; only show vertices vertices = vtk.vtkCellArray() vertices.InsertNextCell(points.shape[0], np.arange(points.shape[0])) poly_data.SetVerts(vertices) # Visualize actor = self._actor_from_poly_data(poly_data) actor.GetProperty().SetPointSize(self.point_size) if colors is not None: self._add_color_to_actor(actor, colors) return self._add_mesh_actor(actor)
def set_quad_grid(self, name, nodes, elements, color, line_width=5, opacity=1.): """ Makes a CQUAD4 grid """ self.create_alternate_vtk_grid(name, color=color, line_width=line_width, opacity=opacity, representation='wire') nnodes = nodes.shape[0] nquads = elements.shape[0] #print(nodes) if nnodes == 0: return if nquads == 0: return #print('adding quad_grid %s; nnodes=%s nquads=%s' % (name, nnodes, nquads)) points = vtk.vtkPoints() points.SetNumberOfPoints(nnodes) for nid, node in enumerate(nodes): #print(nid, node) points.InsertPoint(nid, *list(node)) #assert vtkQuad().GetCellType() == 9, elem.GetCellType() self.alt_grids[name].Allocate(nquads, 1000) for element in elements: elem = vtk.vtkQuad() point_ids = elem.GetPointIds() point_ids.SetId(0, element[0]) point_ids.SetId(1, element[1]) point_ids.SetId(2, element[2]) point_ids.SetId(3, element[3]) self.alt_grids[name].InsertNextCell(9, elem.GetPointIds()) self.alt_grids[name].SetPoints(points) self._add_alt_actors({name : self.alt_grids[name]}) #if name in self.geometry_actors: self.geometry_actors[name].Modified()
def quad_poly_data(width, height): from vtk import vtkPoints, vtkQuad, vtkCellArray, vtkPolyData points = vtkPoints() points.InsertNextPoint((-1 * int(width / 2.0), int(height / 2.0), 0)) points.InsertNextPoint((int(width / 2.0), int(height / 2.0), 0)) points.InsertNextPoint((int(width / 2.0), -1 * int(height / 2.0), 0)) points.InsertNextPoint((-1 * int(width / 2.0), -1 * int(height / 2.0), 0)) quad = vtkQuad() quad.GetPointIds().SetId(0, 0) quad.GetPointIds().SetId(1, 1) quad.GetPointIds().SetId(2, 2) quad.GetPointIds().SetId(3, 3) arr = vtkCellArray() arr.InsertNextCell(quad) pd = vtkPolyData() pd.SetPoints(points) pd.SetPolys(arr) return pd
def buildFullVTKGrid(self): # Create the points for VTK points = vtk.vtkPoints() for i in range(0, len(self.mesh.coords)/3): p = self.mesh.coords[(i*3):(i*3+3)] points.InsertNextPoint(p) #add the points and cells to unstructured grid vtkgrid = vtk.vtkUnstructuredGrid() vtkgrid.SetPoints(points) #add the VTK elements to the mesh for element in self.mesh.elements: type = element.getType() nodes = element.nodes cell = vtk.vtkTriangle() if type == eTypes.TRI: cell = vtk.vtkTriangle() elif type == eTypes.QUAD: cell = vtk.vtkQuad() elif type == eTypes.TET: cell = vtk.vtkTetra() elif type == eTypes.PYRAMID: cell = vtk.vtkPyramid() elif type == eTypes.PRISM: cell = vtk.vtkWedge() #prism elif type == eTypes.HEX: cell = vtk.vtkHexahedron() else: raise # throw an exception j = 0 for n in nodes: cell.GetPointIds().SetId(j,n) j = j+1 vtkgrid.InsertNextCell(cell.GetCellType(), cell.GetPointIds()) return vtkgrid
newNodes[2] = nodes[3] newNodes[3] = nodes[2] return newNodes if VtkSupport(): VTK_UNKNOWN = None VTK_EMPTY_CELL = vtk.vtkEmptyCell().GetCellType() VTK_VERTEX = vtk.vtkVertex().GetCellType() VTK_LINE = vtk.vtkLine().GetCellType() VTK_QUADRATIC_LINE = vtk.vtkQuadraticEdge().GetCellType() VTK_TRIANGLE = vtk.vtkTriangle().GetCellType() VTK_QUADRATIC_TRIANGLE = vtk.vtkQuadraticTriangle().GetCellType() VTK_TETRAHEDRON = vtk.vtkTetra().GetCellType() VTK_QUADRATIC_TETRAHEDRON = vtk.vtkQuadraticTetra().GetCellType() VTK_QUAD = vtk.vtkQuad().GetCellType() VTK_HEXAHEDRON = vtk.vtkHexahedron().GetCellType() vtkTypeIds = ( \ VTK_UNKNOWN, \ VTK_EMPTY_CELL, \ VTK_VERTEX, \ VTK_LINE, VTK_QUADRATIC_LINE, \ VTK_TRIANGLE, VTK_QUADRATIC_TRIANGLE, VTK_QUAD, \ VTK_TETRAHEDRON, VTK_QUADRATIC_TETRAHEDRON, VTK_HEXAHEDRON \ ) class VtkType(elements.ElementType): """ Class defining a VTK element type """
aPixelGrid.InsertNextCell(aPixel.GetCellType(), aPixel.GetPointIds()) aPixelGrid.SetPoints(pixelPoints) aPixelMapper = vtk.vtkDataSetMapper() aPixelMapper.SetInputData(aPixelGrid) aPixelActor = vtk.vtkActor() aPixelActor.SetMapper(aPixelMapper) aPixelActor.AddPosition(0, 0, 2) aPixelActor.GetProperty().BackfaceCullingOn() # Quad quadPoints = vtk.vtkPoints() quadPoints.SetNumberOfPoints(4) quadPoints.InsertPoint(0, 0, 0, 0) quadPoints.InsertPoint(1, 1, 0, 0) quadPoints.InsertPoint(2, 1, 1, 0) quadPoints.InsertPoint(3, 0, 1, 0) aQuad = vtk.vtkQuad() aQuad.GetPointIds().SetId(0, 0) aQuad.GetPointIds().SetId(1, 1) aQuad.GetPointIds().SetId(2, 2) aQuad.GetPointIds().SetId(3, 3) aQuadGrid = vtk.vtkUnstructuredGrid() aQuadGrid.Allocate(1, 1) aQuadGrid.InsertNextCell(aQuad.GetCellType(), aQuad.GetPointIds()) aQuadGrid.SetPoints(quadPoints) aQuadMapper = vtk.vtkDataSetMapper() aQuadMapper.SetInputData(aQuadGrid) aQuadActor = vtk.vtkActor() aQuadActor.SetMapper(aQuadMapper) aQuadActor.AddPosition(2, 0, 2) aQuadActor.GetProperty().BackfaceCullingOn() # Triangle
def rhombic_dodecahedron(): # http://www.vtk.org/pipermail/vtkusers/2014-September/085077.html import vtk # This is a Rhombic Dodecahedron. # First, you need to store the vertex locations. vertex_locations = vtk.vtkPoints() vertex_locations.SetNumberOfPoints(14) vertex_locations.SetPoint( 0, (-0.816497, -0.816497, 0.00000)) vertex_locations.SetPoint( 1, (-0.816497, 0.000000, -0.57735)) vertex_locations.SetPoint( 2, (-0.816497, 0.000000, 0.57735)) vertex_locations.SetPoint( 3, (-0.816497, 0.816497, 0.00000)) vertex_locations.SetPoint( 4, ( 0.000000, -0.816497, -0.57735)) vertex_locations.SetPoint( 5, ( 0.000000, -0.816497, 0.57735)) vertex_locations.SetPoint( 6, ( 0.000000, 0.000000, -1.15470)) vertex_locations.SetPoint( 7, ( 0.000000, 0.000000, 1.15470)) vertex_locations.SetPoint( 8, ( 0.000000, 0.816497, -0.57735)) vertex_locations.SetPoint( 9, ( 0.000000, 0.816497, 0.57735)) vertex_locations.SetPoint(10, ( 0.816497, -0.816497, 0.00000)) vertex_locations.SetPoint(11, ( 0.816497, 0.000000, -0.57735)) vertex_locations.SetPoint(12, ( 0.816497, 0.000000, 0.57735)) vertex_locations.SetPoint(13, ( 0.816497, 0.816497, 0.00000)) # Next, you describe the polygons that represent the faces using the vertex # indices in the vtkPoints that stores the vertex locations. There are a #number # of ways to do this that you can find in examples on the Wiki. polygon_faces = vtk.vtkCellArray() q = vtk.vtkQuad() q.GetPointIds().SetId(0, 7) q.GetPointIds().SetId(1, 12) q.GetPointIds().SetId(2, 10) q.GetPointIds().SetId(3, 5) polygon_faces.InsertNextCell(q) q = vtk.vtkQuad() q.GetPointIds().SetId(0, 7) q.GetPointIds().SetId(1, 12) q.GetPointIds().SetId(2, 13) q.GetPointIds().SetId(3, 9) polygon_faces.InsertNextCell(q) q = vtk.vtkQuad() q.GetPointIds().SetId(0, 7) q.GetPointIds().SetId(1, 9) q.GetPointIds().SetId(2, 3) q.GetPointIds().SetId(3, 2) polygon_faces.InsertNextCell(q) q = vtk.vtkQuad() q.GetPointIds().SetId(0, 7) q.GetPointIds().SetId(1, 2) q.GetPointIds().SetId(2, 0) q.GetPointIds().SetId(3, 5) polygon_faces.InsertNextCell(q) q = vtk.vtkQuad() q.GetPointIds().SetId(0, 6) q.GetPointIds().SetId(1, 11) q.GetPointIds().SetId(2, 10) q.GetPointIds().SetId(3, 4) polygon_faces.InsertNextCell(q) q = vtk.vtkQuad() q.GetPointIds().SetId(0, 6) q.GetPointIds().SetId(1, 4) q.GetPointIds().SetId(2, 0) q.GetPointIds().SetId(3, 1) polygon_faces.InsertNextCell(q) q = vtk.vtkQuad() q.GetPointIds().SetId(0, 6) q.GetPointIds().SetId(1, 1) q.GetPointIds().SetId(2, 3) q.GetPointIds().SetId(3, 8) polygon_faces.InsertNextCell(q) q = vtk.vtkQuad() q.GetPointIds().SetId(0, 6) q.GetPointIds().SetId(1, 8) q.GetPointIds().SetId(2, 13) q.GetPointIds().SetId(3, 11) polygon_faces.InsertNextCell(q) q = vtk.vtkQuad() q.GetPointIds().SetId(0, 10) q.GetPointIds().SetId(1, 11) q.GetPointIds().SetId(2, 13) q.GetPointIds().SetId(3, 12) polygon_faces.InsertNextCell(q) q = vtk.vtkQuad() q.GetPointIds().SetId(0, 13) q.GetPointIds().SetId(1, 8) q.GetPointIds().SetId(2, 3) q.GetPointIds().SetId(3, 9) polygon_faces.InsertNextCell(q) q = vtk.vtkQuad() q.GetPointIds().SetId(0, 3) q.GetPointIds().SetId(1, 1) q.GetPointIds().SetId(2, 0) q.GetPointIds().SetId(3, 2) polygon_faces.InsertNextCell(q) q = vtk.vtkQuad() q.GetPointIds().SetId(0, 0) q.GetPointIds().SetId(1, 4) q.GetPointIds().SetId(2, 10) q.GetPointIds().SetId(3, 5) polygon_faces.InsertNextCell(q) # Next you create a vtkPolyData to store your face and vertex information #that # represents your polyhedron. pd = vtk.vtkPolyData() pd.SetPoints(vertex_locations) pd.SetPolys(polygon_faces) # If you wanted to be able to load in the saved file and select the entire # polyhedron, you would need to save it as a vtkUnstructuredGrid, and you #would # need to put the data into a vtkPolyhedron. This is a bit more involved #than # the vtkPolyData that I used above. For a more in-depth discussion, see: # http://www.vtk.org/Wiki/VTK/Polyhedron_Support # Based on the link above, I need to construct a face stream: face_stream = vtk.vtkIdList() face_stream.InsertNextId(polygon_faces.GetNumberOfCells()) vertex_list = vtk.vtkIdList() polygon_faces.InitTraversal() while polygon_faces.GetNextCell(vertex_list) == 1: face_stream.InsertNextId(vertex_list.GetNumberOfIds()) for j in range(vertex_list.GetNumberOfIds()): face_stream.InsertNextId(vertex_list.GetId(j)) ug = vtk.vtkUnstructuredGrid() ug.SetPoints(vertex_locations) ug.InsertNextCell(vtk.VTK_POLYHEDRON, face_stream) #--------------# # output stuff # #--------------# writer = vtk.vtkUnstructuredGridWriter() writer.SetFileName("rhombic_dodecahedron.vtk") #writer.SetInputData(ug) writer.SetInput(ug) writer.Write() #---------------------# # visualization stuff # #---------------------# # mapper = vtk.vtkPolyDataMapper() # mapper.SetInputData(pd) mapper = vtk.vtkDataSetMapper() mapper.SetInput(ug) actor = vtk.vtkActor() actor.SetMapper(mapper) ren = vtk.vtkRenderer() ren.AddActor(actor) renw = vtk.vtkRenderWindow() renw.AddRenderer(ren) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renw) ren.ResetCamera() renw.Render() iren.Start()
def load_ugrid_geometry(self, ugrid_filename, dirname, name='main', plot=True): #skip_reading = self.remove_old_openfoam_geometry(openfoam_filename) #if skip_reading: # return if is_binary_file(ugrid_filename): model = UGRID(log=self.log, debug=True) base, fmt, ext = os.path.basename(ugrid_filename).split('.') is_2d = False else: base, ext = os.path.basename(ugrid_filename).split('.') model = UGRID2D_Reader(log=self.log, debug=True) is_2d = True self.model_type = 'ugrid' print('ugrid_filename = %s' % ugrid_filename) assert ext == 'ugrid', ugrid_filename model.read_ugrid(ugrid_filename) if is_2d: tris = model.tris quads = model.quads else: tris = model.tris - 1 quads = model.quads - 1 #self.nodes = nodes #self.tris = tris #self.quads = quads #self.pids = pids #self.tets = tets #self.penta5s = penta5s #self.penta6s = penta6s #self.hexas = hexas nnodes = model.nodes.shape[0] ntris = model.tris.shape[0] nquads = model.quads.shape[0] nelements = ntris + nquads nodes = model.nodes self.nElements = nelements self.nNodes = nnodes print("nNodes = %s" % self.nNodes) print("nElements = %s" % self.nElements) assert nelements > 0, nelements self.grid.Allocate(self.nElements, 1000) points = vtk.vtkPoints() points.SetNumberOfPoints(self.nNodes) mmax = amax(nodes, axis=0) mmin = amin(nodes, axis=0) dim_max = (mmax - mmin).max() self.create_global_axes(dim_max) self.log.info('max = %s' % mmax) self.log.info('min = %s' % mmin) diff_node_ids = model.check_hanging_nodes(stop_on_diff=False) if len(diff_node_ids): red = (1., 0., 0.) self.create_alternate_vtk_grid('hanging_nodes', color=red, line_width=5, opacity=1., point_size=10, representation='point') self._add_ugrid_nodes_to_grid('hanging_nodes', diff_node_ids, nodes) self._add_alt_actors(self.alt_grids) for inode, node in enumerate(nodes): points.InsertPoint(inode, node) if ntris: for eid, element in enumerate(tris): elem = vtkTriangle() elem.GetPointIds().SetId(0, element[0]) elem.GetPointIds().SetId(1, element[1]) elem.GetPointIds().SetId(2, element[2]) self.grid.InsertNextCell(elem.GetCellType(), elem.GetPointIds()) if nquads: for eid, element in enumerate(quads): elem = vtkQuad() elem.GetPointIds().SetId(0, element[0]) elem.GetPointIds().SetId(1, element[1]) elem.GetPointIds().SetId(2, element[2]) elem.GetPointIds().SetId(3, element[3]) self.grid.InsertNextCell(elem.GetCellType(), elem.GetPointIds()) self.nElements = nelements self.grid.SetPoints(points) self.grid.Modified() print('update...') if hasattr(self.grid, 'Update'): self.grid.Update() #print("updated grid") # loadCart3dResults - regions/loads self. turn_text_on() self.scalarBar.VisibilityOn() self.scalarBar.Modified() self.iSubcaseNameMap = {1: ['AFLR UGRID Surface', '']} cases = {} ID = 1 if hasattr(model, 'pids'): form, cases = self._fill_ugrid3d_case(ugrid_filename, cases, ID, nnodes, nelements, model) else: form, cases = self._fill_ugrid2d_case(ugrid_filename, cases, ID, nnodes, nelements, model) if plot: self._finish_results_io2(form, cases)
def load_shabp_geometry(self, shabp_filename, name='main', plot=True): self.eid_maps[name] = {} self.nid_maps[name] = {} #key = self.case_keys[self.icase] #case = self.result_cases[key] skip_reading = self._remove_old_geometry(shabp_filename) if skip_reading: return self.model = read_shabp(shabp_filename, log=self.log, debug=self.debug) self.model_type = 'shabp' # model.model_type nodes, elements, patches, components, impact, shadow = self.model.getPointsElementsRegions( ) #for nid,node in enumerate(nodes): #print "node[%s] = %s" %(nid,str(node)) nnodes = len(nodes) self.nnodes = len(nodes) self.nelements = len(elements) #print("nnodes = ",self.nnodes) #print("nelements = ", self.nelements) self.grid.Allocate(self.nelements, 1000) #self.gridResult.SetNumberOfComponents(self.nelements) points = vtk.vtkPoints() points.SetNumberOfPoints(self.nnodes) #self.gridResult.Allocate(self.nnodes, 1000) #vectorReselt.SetNumberOfComponents(3) #elem.SetNumberOfPoints(nnodes) #if 0: #fraction = 1. / nnodes # so you can color the nodes by ID #for nid, node in sorted(iteritems(nodes)): #points.InsertPoint(nid - 1, *node) #self.gridResult.InsertNextValue(nid * fraction) #print str(element) #elem = vtk.vtkVertex() #elem.GetPointIds().SetId(0, i) #self.aQuadGrid.InsertNextCell(elem.GetCellType(), elem.GetPointIds()) #vectorResult.InsertTuple3(0, 0.0, 0.0, 1.0) assert len(nodes) > 0 mmax = amax(nodes, axis=0) mmin = amin(nodes, axis=0) dim_max = (mmax - mmin).max() self.create_global_axes(dim_max) for nid, node in enumerate(nodes): points.InsertPoint(nid, *node) assert len(elements) > 0 for eid, element in enumerate(elements): (p1, p2, p3, p4) = element elem = vtkQuad() elem.GetPointIds().SetId(0, p1) elem.GetPointIds().SetId(1, p2) elem.GetPointIds().SetId(2, p3) elem.GetPointIds().SetId(3, p4) self.grid.InsertNextCell(elem.GetCellType(), elem.GetPointIds()) self.grid.SetPoints(points) #self.grid.GetPointData().SetScalars(self.gridResult) #print dir(self.grid) #.SetNumberOfComponents(0) #self.grid.GetCellData().SetNumberOfTuples(1); #self.grid.GetCellData().SetScalars(self.gridResult) self.grid.Modified() if hasattr(self.grid, 'Update'): self.grid.Update() # loadShabpResults - regions/loads self.scalarBar.VisibilityOn() self.scalarBar.Modified() self.isubcase_name_map = {1: ['S/HABP', '']} cases = {} ID = 1 self.log.debug("nNodes=%i nElements=%i" % (self.nnodes, self.nelements)) form, cases = self._fill_shabp_geometry_case(cases, ID, nodes, elements, patches, components, impact, shadow) self._finish_results_io2(form, cases)
def buildMesh(xNumCells, yNumCells, filename): polydata = vtk.vtkPolyData() points = vtk.vtkPoints() quads = vtk.vtkCellArray() counter = 0 xBase = 0 yBase = 0 xStep = quadLength/(xNumCells * 1.0) # Focing float division (python 2). yStep = quadHeight/(yNumCells * 1.0) branchId = vtk.vtkDoubleArray() branchId.SetName("branchId") # Three rectangles in space for a bifurcation. if bifurcation == True: stopAt = 3 else: stopAt = 1 for k in range(0, stopAt): if k == 1: xBase = - quadLength * (xQuads / 2) yBase = quadHeight * yQuads elif k == 2: xBase = + quadLength * (xQuads / 2) yBase = quadHeight * yQuads # The framework for each quad. The total number is set by globals. for i in range(0, yQuads): for j in range(0, xQuads): # For how ever many cells are within each main quad. # The total number is decided by the function parameters. for x in range(0, yNumCells): for y in range(0, xNumCells): quad = vtk.vtkQuad() p0 = [y * xStep + xBase + (quadLength * j), x * yStep + yBase + (quadHeight * i), 0] p1 = [(y + 1) * xStep + xBase + (quadLength * j), x * yStep + yBase + (quadHeight * i), 0] p2 = [(y + 1) * xStep + xBase + (quadLength * j), (x + 1) * yStep + yBase + (quadHeight * i), 0] p3 = [y * xStep + xBase + (quadLength * j), (x + 1) * yStep + yBase + (quadHeight * i), 0] points.InsertNextPoint(p0) points.InsertNextPoint(p1) points.InsertNextPoint(p2) points.InsertNextPoint(p3) quad.GetPointIds().InsertId(0, counter) quad.GetPointIds().InsertId(1, counter + 1) quad.GetPointIds().InsertId(2, counter + 2) quad.GetPointIds().InsertId(3, counter + 3) counter += 4 quads.InsertNextCell(quad) branchId.InsertNextValue(k) polydata.SetPoints(points) polydata.SetPolys(quads) polydata.GetCellData().SetScalars(branchId) polyDataWriter = vtk.vtkXMLPolyDataWriter() polyDataWriter.SetFileName(filename) polyDataWriter.SetInputData(polydata) polyDataWriter.Write() return polydata
def testCells(self): # Demonstrates all cell types # # NOTE: the use of NewInstance/DeepCopy is included to increase # regression coverage. It is not required in most applications. ren = vtk.vtkRenderer() # turn off all cullers ren.GetCullers().RemoveAllItems() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) renWin.SetSize(300, 150) iRen = vtk.vtkRenderWindowInteractor() iRen.SetRenderWindow(renWin) # create a scene with one of each cell type # Voxel voxelPoints = vtk.vtkPoints() voxelPoints.SetNumberOfPoints(8) voxelPoints.InsertPoint(0, 0, 0, 0) voxelPoints.InsertPoint(1, 1, 0, 0) voxelPoints.InsertPoint(2, 0, 1, 0) voxelPoints.InsertPoint(3, 1, 1, 0) voxelPoints.InsertPoint(4, 0, 0, 1) voxelPoints.InsertPoint(5, 1, 0, 1) voxelPoints.InsertPoint(6, 0, 1, 1) voxelPoints.InsertPoint(7, 1, 1, 1) aVoxel = vtk.vtkVoxel() aVoxel.GetPointIds().SetId(0, 0) aVoxel.GetPointIds().SetId(1, 1) aVoxel.GetPointIds().SetId(2, 2) aVoxel.GetPointIds().SetId(3, 3) aVoxel.GetPointIds().SetId(4, 4) aVoxel.GetPointIds().SetId(5, 5) aVoxel.GetPointIds().SetId(6, 6) aVoxel.GetPointIds().SetId(7, 7) bVoxel = aVoxel.NewInstance() bVoxel.DeepCopy(aVoxel) aVoxelGrid = vtk.vtkUnstructuredGrid() aVoxelGrid.Allocate(1, 1) aVoxelGrid.InsertNextCell(aVoxel.GetCellType(), aVoxel.GetPointIds()) aVoxelGrid.SetPoints(voxelPoints) aVoxelMapper = vtk.vtkDataSetMapper() aVoxelMapper.SetInputData(aVoxelGrid) aVoxelActor = vtk.vtkActor() aVoxelActor.SetMapper(aVoxelMapper) aVoxelActor.GetProperty().BackfaceCullingOn() # Hexahedron hexahedronPoints = vtk.vtkPoints() hexahedronPoints.SetNumberOfPoints(8) hexahedronPoints.InsertPoint(0, 0, 0, 0) hexahedronPoints.InsertPoint(1, 1, 0, 0) hexahedronPoints.InsertPoint(2, 1, 1, 0) hexahedronPoints.InsertPoint(3, 0, 1, 0) hexahedronPoints.InsertPoint(4, 0, 0, 1) hexahedronPoints.InsertPoint(5, 1, 0, 1) hexahedronPoints.InsertPoint(6, 1, 1, 1) hexahedronPoints.InsertPoint(7, 0, 1, 1) aHexahedron = vtk.vtkHexahedron() aHexahedron.GetPointIds().SetId(0, 0) aHexahedron.GetPointIds().SetId(1, 1) aHexahedron.GetPointIds().SetId(2, 2) aHexahedron.GetPointIds().SetId(3, 3) aHexahedron.GetPointIds().SetId(4, 4) aHexahedron.GetPointIds().SetId(5, 5) aHexahedron.GetPointIds().SetId(6, 6) aHexahedron.GetPointIds().SetId(7, 7) bHexahedron = aHexahedron.NewInstance() bHexahedron.DeepCopy(aHexahedron) aHexahedronGrid = vtk.vtkUnstructuredGrid() aHexahedronGrid.Allocate(1, 1) aHexahedronGrid.InsertNextCell(aHexahedron.GetCellType(), aHexahedron.GetPointIds()) aHexahedronGrid.SetPoints(hexahedronPoints) aHexahedronMapper = vtk.vtkDataSetMapper() aHexahedronMapper.SetInputData(aHexahedronGrid) aHexahedronActor = vtk.vtkActor() aHexahedronActor.SetMapper(aHexahedronMapper) aHexahedronActor.AddPosition(2, 0, 0) aHexahedronActor.GetProperty().BackfaceCullingOn() # Tetra tetraPoints = vtk.vtkPoints() tetraPoints.SetNumberOfPoints(4) tetraPoints.InsertPoint(0, 0, 0, 0) tetraPoints.InsertPoint(1, 1, 0, 0) tetraPoints.InsertPoint(2, 0.5, 1, 0) tetraPoints.InsertPoint(3, 0.5, 0.5, 1) aTetra = vtk.vtkTetra() aTetra.GetPointIds().SetId(0, 0) aTetra.GetPointIds().SetId(1, 1) aTetra.GetPointIds().SetId(2, 2) aTetra.GetPointIds().SetId(3, 3) bTetra = aTetra.NewInstance() bTetra.DeepCopy(aTetra) aTetraGrid = vtk.vtkUnstructuredGrid() aTetraGrid.Allocate(1, 1) aTetraGrid.InsertNextCell(aTetra.GetCellType(), aTetra.GetPointIds()) aTetraGrid.SetPoints(tetraPoints) aTetraCopy = vtk.vtkUnstructuredGrid() aTetraCopy.ShallowCopy(aTetraGrid) aTetraMapper = vtk.vtkDataSetMapper() aTetraMapper.SetInputData(aTetraCopy) aTetraActor = vtk.vtkActor() aTetraActor.SetMapper(aTetraMapper) aTetraActor.AddPosition(4, 0, 0) aTetraActor.GetProperty().BackfaceCullingOn() # Wedge wedgePoints = vtk.vtkPoints() wedgePoints.SetNumberOfPoints(6) wedgePoints.InsertPoint(0, 0, 1, 0) wedgePoints.InsertPoint(1, 0, 0, 0) wedgePoints.InsertPoint(2, 0, 0.5, 0.5) wedgePoints.InsertPoint(3, 1, 1, 0) wedgePoints.InsertPoint(4, 1, 0, 0) wedgePoints.InsertPoint(5, 1, 0.5, 0.5) aWedge = vtk.vtkWedge() aWedge.GetPointIds().SetId(0, 0) aWedge.GetPointIds().SetId(1, 1) aWedge.GetPointIds().SetId(2, 2) aWedge.GetPointIds().SetId(3, 3) aWedge.GetPointIds().SetId(4, 4) aWedge.GetPointIds().SetId(5, 5) bWedge = aWedge.NewInstance() bWedge.DeepCopy(aWedge) aWedgeGrid = vtk.vtkUnstructuredGrid() aWedgeGrid.Allocate(1, 1) aWedgeGrid.InsertNextCell(aWedge.GetCellType(), aWedge.GetPointIds()) aWedgeGrid.SetPoints(wedgePoints) aWedgeCopy = vtk.vtkUnstructuredGrid() aWedgeCopy.DeepCopy(aWedgeGrid) aWedgeMapper = vtk.vtkDataSetMapper() aWedgeMapper.SetInputData(aWedgeCopy) aWedgeActor = vtk.vtkActor() aWedgeActor.SetMapper(aWedgeMapper) aWedgeActor.AddPosition(6, 0, 0) aWedgeActor.GetProperty().BackfaceCullingOn() # Pyramid pyramidPoints = vtk.vtkPoints() pyramidPoints.SetNumberOfPoints(5) pyramidPoints.InsertPoint(0, 0, 0, 0) pyramidPoints.InsertPoint(1, 1, 0, 0) pyramidPoints.InsertPoint(2, 1, 1, 0) pyramidPoints.InsertPoint(3, 0, 1, 0) pyramidPoints.InsertPoint(4, 0.5, 0.5, 1) aPyramid = vtk.vtkPyramid() aPyramid.GetPointIds().SetId(0, 0) aPyramid.GetPointIds().SetId(1, 1) aPyramid.GetPointIds().SetId(2, 2) aPyramid.GetPointIds().SetId(3, 3) aPyramid.GetPointIds().SetId(4, 4) bPyramid = aPyramid.NewInstance() bPyramid.DeepCopy(aPyramid) aPyramidGrid = vtk.vtkUnstructuredGrid() aPyramidGrid.Allocate(1, 1) aPyramidGrid.InsertNextCell(aPyramid.GetCellType(), aPyramid.GetPointIds()) aPyramidGrid.SetPoints(pyramidPoints) aPyramidMapper = vtk.vtkDataSetMapper() aPyramidMapper.SetInputData(aPyramidGrid) aPyramidActor = vtk.vtkActor() aPyramidActor.SetMapper(aPyramidMapper) aPyramidActor.AddPosition(8, 0, 0) aPyramidActor.GetProperty().BackfaceCullingOn() # Pixel pixelPoints = vtk.vtkPoints() pixelPoints.SetNumberOfPoints(4) pixelPoints.InsertPoint(0, 0, 0, 0) pixelPoints.InsertPoint(1, 1, 0, 0) pixelPoints.InsertPoint(2, 0, 1, 0) pixelPoints.InsertPoint(3, 1, 1, 0) aPixel = vtk.vtkPixel() aPixel.GetPointIds().SetId(0, 0) aPixel.GetPointIds().SetId(1, 1) aPixel.GetPointIds().SetId(2, 2) aPixel.GetPointIds().SetId(3, 3) bPixel = aPixel.NewInstance() bPixel.DeepCopy(aPixel) aPixelGrid = vtk.vtkUnstructuredGrid() aPixelGrid.Allocate(1, 1) aPixelGrid.InsertNextCell(aPixel.GetCellType(), aPixel.GetPointIds()) aPixelGrid.SetPoints(pixelPoints) aPixelMapper = vtk.vtkDataSetMapper() aPixelMapper.SetInputData(aPixelGrid) aPixelActor = vtk.vtkActor() aPixelActor.SetMapper(aPixelMapper) aPixelActor.AddPosition(0, 0, 2) aPixelActor.GetProperty().BackfaceCullingOn() # Quad quadPoints = vtk.vtkPoints() quadPoints.SetNumberOfPoints(4) quadPoints.InsertPoint(0, 0, 0, 0) quadPoints.InsertPoint(1, 1, 0, 0) quadPoints.InsertPoint(2, 1, 1, 0) quadPoints.InsertPoint(3, 0, 1, 0) aQuad = vtk.vtkQuad() aQuad.GetPointIds().SetId(0, 0) aQuad.GetPointIds().SetId(1, 1) aQuad.GetPointIds().SetId(2, 2) aQuad.GetPointIds().SetId(3, 3) bQuad = aQuad.NewInstance() bQuad.DeepCopy(aQuad) aQuadGrid = vtk.vtkUnstructuredGrid() aQuadGrid.Allocate(1, 1) aQuadGrid.InsertNextCell(aQuad.GetCellType(), aQuad.GetPointIds()) aQuadGrid.SetPoints(quadPoints) aQuadMapper = vtk.vtkDataSetMapper() aQuadMapper.SetInputData(aQuadGrid) aQuadActor = vtk.vtkActor() aQuadActor.SetMapper(aQuadMapper) aQuadActor.AddPosition(2, 0, 2) aQuadActor.GetProperty().BackfaceCullingOn() # Triangle trianglePoints = vtk.vtkPoints() trianglePoints.SetNumberOfPoints(3) trianglePoints.InsertPoint(0, 0, 0, 0) trianglePoints.InsertPoint(1, 1, 0, 0) trianglePoints.InsertPoint(2, 0.5, 0.5, 0) triangleTCoords = vtk.vtkFloatArray() triangleTCoords.SetNumberOfComponents(2) triangleTCoords.SetNumberOfTuples(3) triangleTCoords.InsertTuple2(0, 1, 1) triangleTCoords.InsertTuple2(1, 2, 2) triangleTCoords.InsertTuple2(2, 3, 3) aTriangle = vtk.vtkTriangle() aTriangle.GetPointIds().SetId(0, 0) aTriangle.GetPointIds().SetId(1, 1) aTriangle.GetPointIds().SetId(2, 2) bTriangle = aTriangle.NewInstance() bTriangle.DeepCopy(aTriangle) aTriangleGrid = vtk.vtkUnstructuredGrid() aTriangleGrid.Allocate(1, 1) aTriangleGrid.InsertNextCell(aTriangle.GetCellType(), aTriangle.GetPointIds()) aTriangleGrid.SetPoints(trianglePoints) aTriangleGrid.GetPointData().SetTCoords(triangleTCoords) aTriangleMapper = vtk.vtkDataSetMapper() aTriangleMapper.SetInputData(aTriangleGrid) aTriangleActor = vtk.vtkActor() aTriangleActor.SetMapper(aTriangleMapper) aTriangleActor.AddPosition(4, 0, 2) aTriangleActor.GetProperty().BackfaceCullingOn() # Polygon polygonPoints = vtk.vtkPoints() polygonPoints.SetNumberOfPoints(4) polygonPoints.InsertPoint(0, 0, 0, 0) polygonPoints.InsertPoint(1, 1, 0, 0) polygonPoints.InsertPoint(2, 1, 1, 0) polygonPoints.InsertPoint(3, 0, 1, 0) aPolygon = vtk.vtkPolygon() aPolygon.GetPointIds().SetNumberOfIds(4) aPolygon.GetPointIds().SetId(0, 0) aPolygon.GetPointIds().SetId(1, 1) aPolygon.GetPointIds().SetId(2, 2) aPolygon.GetPointIds().SetId(3, 3) bPolygon = aPolygon.NewInstance() bPolygon.DeepCopy(aPolygon) aPolygonGrid = vtk.vtkUnstructuredGrid() aPolygonGrid.Allocate(1, 1) aPolygonGrid.InsertNextCell(aPolygon.GetCellType(), aPolygon.GetPointIds()) aPolygonGrid.SetPoints(polygonPoints) aPolygonMapper = vtk.vtkDataSetMapper() aPolygonMapper.SetInputData(aPolygonGrid) aPolygonActor = vtk.vtkActor() aPolygonActor.SetMapper(aPolygonMapper) aPolygonActor.AddPosition(6, 0, 2) aPolygonActor.GetProperty().BackfaceCullingOn() # Triangle Strip triangleStripPoints = vtk.vtkPoints() triangleStripPoints.SetNumberOfPoints(5) triangleStripPoints.InsertPoint(0, 0, 1, 0) triangleStripPoints.InsertPoint(1, 0, 0, 0) triangleStripPoints.InsertPoint(2, 1, 1, 0) triangleStripPoints.InsertPoint(3, 1, 0, 0) triangleStripPoints.InsertPoint(4, 2, 1, 0) triangleStripTCoords = vtk.vtkFloatArray() triangleStripTCoords.SetNumberOfComponents(2) triangleStripTCoords.SetNumberOfTuples(3) triangleStripTCoords.InsertTuple2(0, 1, 1) triangleStripTCoords.InsertTuple2(1, 2, 2) triangleStripTCoords.InsertTuple2(2, 3, 3) triangleStripTCoords.InsertTuple2(3, 4, 4) triangleStripTCoords.InsertTuple2(4, 5, 5) aTriangleStrip = vtk.vtkTriangleStrip() aTriangleStrip.GetPointIds().SetNumberOfIds(5) aTriangleStrip.GetPointIds().SetId(0, 0) aTriangleStrip.GetPointIds().SetId(1, 1) aTriangleStrip.GetPointIds().SetId(2, 2) aTriangleStrip.GetPointIds().SetId(3, 3) aTriangleStrip.GetPointIds().SetId(4, 4) bTriangleStrip = aTriangleStrip.NewInstance() bTriangleStrip.DeepCopy(aTriangleStrip) aTriangleStripGrid = vtk.vtkUnstructuredGrid() aTriangleStripGrid.Allocate(1, 1) aTriangleStripGrid.InsertNextCell(aTriangleStrip.GetCellType(), aTriangleStrip.GetPointIds()) aTriangleStripGrid.SetPoints(triangleStripPoints) aTriangleStripGrid.GetPointData().SetTCoords(triangleStripTCoords) aTriangleStripMapper = vtk.vtkDataSetMapper() aTriangleStripMapper.SetInputData(aTriangleStripGrid) aTriangleStripActor = vtk.vtkActor() aTriangleStripActor.SetMapper(aTriangleStripMapper) aTriangleStripActor.AddPosition(8, 0, 2) aTriangleStripActor.GetProperty().BackfaceCullingOn() # Line linePoints = vtk.vtkPoints() linePoints.SetNumberOfPoints(2) linePoints.InsertPoint(0, 0, 0, 0) linePoints.InsertPoint(1, 1, 1, 0) aLine = vtk.vtkLine() aLine.GetPointIds().SetId(0, 0) aLine.GetPointIds().SetId(1, 1) bLine = aLine.NewInstance() bLine.DeepCopy(aLine) aLineGrid = vtk.vtkUnstructuredGrid() aLineGrid.Allocate(1, 1) aLineGrid.InsertNextCell(aLine.GetCellType(), aLine.GetPointIds()) aLineGrid.SetPoints(linePoints) aLineMapper = vtk.vtkDataSetMapper() aLineMapper.SetInputData(aLineGrid) aLineActor = vtk.vtkActor() aLineActor.SetMapper(aLineMapper) aLineActor.AddPosition(0, 0, 4) aLineActor.GetProperty().BackfaceCullingOn() # Poly line polyLinePoints = vtk.vtkPoints() polyLinePoints.SetNumberOfPoints(3) polyLinePoints.InsertPoint(0, 0, 0, 0) polyLinePoints.InsertPoint(1, 1, 1, 0) polyLinePoints.InsertPoint(2, 1, 0, 0) aPolyLine = vtk.vtkPolyLine() aPolyLine.GetPointIds().SetNumberOfIds(3) aPolyLine.GetPointIds().SetId(0, 0) aPolyLine.GetPointIds().SetId(1, 1) aPolyLine.GetPointIds().SetId(2, 2) bPolyLine = aPolyLine.NewInstance() bPolyLine.DeepCopy(aPolyLine) aPolyLineGrid = vtk.vtkUnstructuredGrid() aPolyLineGrid.Allocate(1, 1) aPolyLineGrid.InsertNextCell(aPolyLine.GetCellType(), aPolyLine.GetPointIds()) aPolyLineGrid.SetPoints(polyLinePoints) aPolyLineMapper = vtk.vtkDataSetMapper() aPolyLineMapper.SetInputData(aPolyLineGrid) aPolyLineActor = vtk.vtkActor() aPolyLineActor.SetMapper(aPolyLineMapper) aPolyLineActor.AddPosition(2, 0, 4) aPolyLineActor.GetProperty().BackfaceCullingOn() # Vertex vertexPoints = vtk.vtkPoints() vertexPoints.SetNumberOfPoints(1) vertexPoints.InsertPoint(0, 0, 0, 0) aVertex = vtk.vtkVertex() aVertex.GetPointIds().SetId(0, 0) bVertex = aVertex.NewInstance() bVertex.DeepCopy(aVertex) aVertexGrid = vtk.vtkUnstructuredGrid() aVertexGrid.Allocate(1, 1) aVertexGrid.InsertNextCell(aVertex.GetCellType(), aVertex.GetPointIds()) aVertexGrid.SetPoints(vertexPoints) aVertexMapper = vtk.vtkDataSetMapper() aVertexMapper.SetInputData(aVertexGrid) aVertexActor = vtk.vtkActor() aVertexActor.SetMapper(aVertexMapper) aVertexActor.AddPosition(0, 0, 6) aVertexActor.GetProperty().BackfaceCullingOn() # Poly Vertex polyVertexPoints = vtk.vtkPoints() polyVertexPoints.SetNumberOfPoints(3) polyVertexPoints.InsertPoint(0, 0, 0, 0) polyVertexPoints.InsertPoint(1, 1, 0, 0) polyVertexPoints.InsertPoint(2, 1, 1, 0) aPolyVertex = vtk.vtkPolyVertex() aPolyVertex.GetPointIds().SetNumberOfIds(3) aPolyVertex.GetPointIds().SetId(0, 0) aPolyVertex.GetPointIds().SetId(1, 1) aPolyVertex.GetPointIds().SetId(2, 2) bPolyVertex = aPolyVertex.NewInstance() bPolyVertex.DeepCopy(aPolyVertex) aPolyVertexGrid = vtk.vtkUnstructuredGrid() aPolyVertexGrid.Allocate(1, 1) aPolyVertexGrid.InsertNextCell(aPolyVertex.GetCellType(), aPolyVertex.GetPointIds()) aPolyVertexGrid.SetPoints(polyVertexPoints) aPolyVertexMapper = vtk.vtkDataSetMapper() aPolyVertexMapper.SetInputData(aPolyVertexGrid) aPolyVertexActor = vtk.vtkActor() aPolyVertexActor.SetMapper(aPolyVertexMapper) aPolyVertexActor.AddPosition(2, 0, 6) aPolyVertexActor.GetProperty().BackfaceCullingOn() # Pentagonal prism pentaPoints = vtk.vtkPoints() pentaPoints.SetNumberOfPoints(10) pentaPoints.InsertPoint(0, 0.25, 0.0, 0.0) pentaPoints.InsertPoint(1, 0.75, 0.0, 0.0) pentaPoints.InsertPoint(2, 1.0, 0.5, 0.0) pentaPoints.InsertPoint(3, 0.5, 1.0, 0.0) pentaPoints.InsertPoint(4, 0.0, 0.5, 0.0) pentaPoints.InsertPoint(5, 0.25, 0.0, 1.0) pentaPoints.InsertPoint(6, 0.75, 0.0, 1.0) pentaPoints.InsertPoint(7, 1.0, 0.5, 1.0) pentaPoints.InsertPoint(8, 0.5, 1.0, 1.0) pentaPoints.InsertPoint(9, 0.0, 0.5, 1.0) aPenta = vtk.vtkPentagonalPrism() aPenta.GetPointIds().SetId(0, 0) aPenta.GetPointIds().SetId(1, 1) aPenta.GetPointIds().SetId(2, 2) aPenta.GetPointIds().SetId(3, 3) aPenta.GetPointIds().SetId(4, 4) aPenta.GetPointIds().SetId(5, 5) aPenta.GetPointIds().SetId(6, 6) aPenta.GetPointIds().SetId(7, 7) aPenta.GetPointIds().SetId(8, 8) aPenta.GetPointIds().SetId(9, 9) bPenta = aPenta.NewInstance() bPenta.DeepCopy(aPenta) aPentaGrid = vtk.vtkUnstructuredGrid() aPentaGrid.Allocate(1, 1) aPentaGrid.InsertNextCell(aPenta.GetCellType(), aPenta.GetPointIds()) aPentaGrid.SetPoints(pentaPoints) aPentaCopy = vtk.vtkUnstructuredGrid() aPentaCopy.DeepCopy(aPentaGrid) aPentaMapper = vtk.vtkDataSetMapper() aPentaMapper.SetInputData(aPentaCopy) aPentaActor = vtk.vtkActor() aPentaActor.SetMapper(aPentaMapper) aPentaActor.AddPosition(10, 0, 0) aPentaActor.GetProperty().BackfaceCullingOn() # Hexagonal prism hexaPoints = vtk.vtkPoints() hexaPoints.SetNumberOfPoints(12) hexaPoints.InsertPoint(0, 0.0, 0.0, 0.0) hexaPoints.InsertPoint(1, 0.5, 0.0, 0.0) hexaPoints.InsertPoint(2, 1.0, 0.5, 0.0) hexaPoints.InsertPoint(3, 1.0, 1.0, 0.0) hexaPoints.InsertPoint(4, 0.5, 1.0, 0.0) hexaPoints.InsertPoint(5, 0.0, 0.5, 0.0) hexaPoints.InsertPoint(6, 0.0, 0.0, 1.0) hexaPoints.InsertPoint(7, 0.5, 0.0, 1.0) hexaPoints.InsertPoint(8, 1.0, 0.5, 1.0) hexaPoints.InsertPoint(9, 1.0, 1.0, 1.0) hexaPoints.InsertPoint(10, 0.5, 1.0, 1.0) hexaPoints.InsertPoint(11, 0.0, 0.5, 1.0) aHexa = vtk.vtkHexagonalPrism() aHexa.GetPointIds().SetId(0, 0) aHexa.GetPointIds().SetId(1, 1) aHexa.GetPointIds().SetId(2, 2) aHexa.GetPointIds().SetId(3, 3) aHexa.GetPointIds().SetId(4, 4) aHexa.GetPointIds().SetId(5, 5) aHexa.GetPointIds().SetId(6, 6) aHexa.GetPointIds().SetId(7, 7) aHexa.GetPointIds().SetId(8, 8) aHexa.GetPointIds().SetId(9, 9) aHexa.GetPointIds().SetId(10, 10) aHexa.GetPointIds().SetId(11, 11) bHexa = aHexa.NewInstance() bHexa.DeepCopy(aHexa) aHexaGrid = vtk.vtkUnstructuredGrid() aHexaGrid.Allocate(1, 1) aHexaGrid.InsertNextCell(aHexa.GetCellType(), aHexa.GetPointIds()) aHexaGrid.SetPoints(hexaPoints) aHexaCopy = vtk.vtkUnstructuredGrid() aHexaCopy.DeepCopy(aHexaGrid) aHexaMapper = vtk.vtkDataSetMapper() aHexaMapper.SetInputData(aHexaCopy) aHexaActor = vtk.vtkActor() aHexaActor.SetMapper(aHexaMapper) aHexaActor.AddPosition(12, 0, 0) aHexaActor.GetProperty().BackfaceCullingOn() # RIB property aRIBProperty = vtk.vtkRIBProperty() aRIBProperty.SetVariable("Km", "float") aRIBProperty.SetSurfaceShader("LGVeinedmarble") aRIBProperty.SetVariable("veinfreq", "float") aRIBProperty.AddVariable("warpfreq", "float") aRIBProperty.AddVariable("veincolor", "color") aRIBProperty.AddParameter("veinfreq", " 2") aRIBProperty.AddParameter("veincolor", "1.0000 1.0000 0.9412") bRIBProperty = vtk.vtkRIBProperty() bRIBProperty.SetVariable("Km", "float") bRIBProperty.SetParameter("Km", "1.0") bRIBProperty.SetDisplacementShader("dented") bRIBProperty.SetSurfaceShader("plastic") aProperty = vtk.vtkProperty() bProperty = vtk.vtkProperty() aTriangleActor.SetProperty(aProperty) aTriangleStripActor.SetProperty(bProperty) ren.SetBackground(0.1, 0.2, 0.4) ren.AddActor(aVoxelActor) aVoxelActor.GetProperty().SetDiffuseColor(1, 0, 0) ren.AddActor(aHexahedronActor) aHexahedronActor.GetProperty().SetDiffuseColor(1, 1, 0) ren.AddActor(aTetraActor) aTetraActor.GetProperty().SetDiffuseColor(0, 1, 0) ren.AddActor(aWedgeActor) aWedgeActor.GetProperty().SetDiffuseColor(0, 1, 1) ren.AddActor(aPyramidActor) aPyramidActor.GetProperty().SetDiffuseColor(1, 0, 1) ren.AddActor(aPixelActor) aPixelActor.GetProperty().SetDiffuseColor(0, 1, 1) ren.AddActor(aQuadActor) aQuadActor.GetProperty().SetDiffuseColor(1, 0, 1) ren.AddActor(aTriangleActor) aTriangleActor.GetProperty().SetDiffuseColor(0.3, 1, 0.5) ren.AddActor(aPolygonActor) aPolygonActor.GetProperty().SetDiffuseColor(1, 0.4, 0.5) ren.AddActor(aTriangleStripActor) aTriangleStripActor.GetProperty().SetDiffuseColor(0.3, 0.7, 1) ren.AddActor(aLineActor) aLineActor.GetProperty().SetDiffuseColor(0.2, 1, 1) ren.AddActor(aPolyLineActor) aPolyLineActor.GetProperty().SetDiffuseColor(1, 1, 1) ren.AddActor(aVertexActor) aVertexActor.GetProperty().SetDiffuseColor(1, 1, 1) ren.AddActor(aPolyVertexActor) aPolyVertexActor.GetProperty().SetDiffuseColor(1, 1, 1) ren.AddActor(aPentaActor) aPentaActor.GetProperty().SetDiffuseColor(0.2, 0.4, 0.7) ren.AddActor(aHexaActor) aHexaActor.GetProperty().SetDiffuseColor(0.7, 0.5, 1) aRIBLight = vtk.vtkRIBLight() aRIBLight.ShadowsOn() aLight = vtk.vtkLight() aLight.PositionalOn() aLight.SetConeAngle(25) ren.AddLight(aLight) ren.ResetCamera() ren.GetActiveCamera().Azimuth(30) ren.GetActiveCamera().Elevation(20) ren.GetActiveCamera().Dolly(2.8) ren.ResetCameraClippingRange() aLight.SetFocalPoint(ren.GetActiveCamera().GetFocalPoint()) aLight.SetPosition(ren.GetActiveCamera().GetPosition()) # write to the temp directory if possible, otherwise use . dir = tempfile.gettempdir() atext = vtk.vtkTexture() pnmReader = vtk.vtkBMPReader() pnmReader.SetFileName(VTK_DATA_ROOT + "/Data/masonry.bmp") atext.SetInputConnection(pnmReader.GetOutputPort()) atext.InterpolateOff() aTriangleActor.SetTexture(atext) rib = vtk.vtkRIBExporter() rib.SetInput(renWin) rib.SetFilePrefix(dir + "/cells") rib.SetTexturePrefix(dir + "/cells") rib.Write() os.remove(dir + "/cells.rib") iv = vtk.vtkIVExporter() iv.SetInput(renWin) iv.SetFileName(dir + "/cells.iv") iv.Write() os.remove(dir + "/cells.iv") obj = vtk.vtkOBJExporter() obj.SetInput(renWin) obj.SetFilePrefix(dir + "/cells") obj.Write() os.remove(dir + "/cells.obj") os.remove(dir + "/cells.mtl") vrml = vtk.vtkVRMLExporter() vrml.SetInput(renWin) # vrml.SetStartWrite(vrml.SetFileName(dir + "/cells.wrl")) # vrml.SetEndWrite(vrml.SetFileName("/a/acells.wrl")) vrml.SetFileName(dir + "/cells.wrl") vrml.SetSpeed(5.5) vrml.Write() os.remove(dir + "/cells.wrl") oogl = vtk.vtkOOGLExporter() oogl.SetInput(renWin) oogl.SetFileName(dir + "/cells.oogl") oogl.Write() os.remove(dir + "/cells.oogl") # the UnRegister calls are because make object is the same as New, # and causes memory leaks. (Python does not treat NewInstance the same as New). def DeleteCopies(): bVoxel.UnRegister(None) bHexahedron.UnRegister(None) bTetra.UnRegister(None) bWedge.UnRegister(None) bPyramid.UnRegister(None) bPixel.UnRegister(None) bQuad.UnRegister(None) bTriangle.UnRegister(None) bPolygon.UnRegister(None) bTriangleStrip.UnRegister(None) bLine.UnRegister(None) bPolyLine.UnRegister(None) bVertex.UnRegister(None) bPolyVertex.UnRegister(None) bPenta.UnRegister(None) bHexa.UnRegister(None) DeleteCopies() # render and interact with data renWin.Render() img_file = "cells.png" vtk.test.Testing.compareImage(iRen.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file), threshold=25) vtk.test.Testing.interact()
def getVolumeVtkGrid(visMesh): """ Returns: vtk.vtkUnstructuredGrid: """ assert isinstance(visMesh, VisMesh) bClipPolyhedra = True vtkpoints = vtk.vtkPoints() for visPoint in visMesh.points: vtkpoints.InsertNextPoint(visPoint.x, visPoint.y, visPoint.z) vtkgrid = vtk.vtkUnstructuredGrid() vtkgrid.Allocate(len(visMesh.points), len(visMesh.points)) vtkgrid.SetPoints(vtkpoints) quadType = vtk.vtkQuad().GetCellType() # lineType = vtk.vtkLine().GetCellType() polygonType = vtk.vtkPolygon().GetCellType() polyhedronType = vtk.vtkPolyhedron().GetCellType() triangleType = vtk.vtkTriangle().GetCellType() voxelType = vtk.vtkVoxel().GetCellType() tetraType = vtk.vtkTetra().GetCellType() if visMesh.polygons != None: for visPolygon in visMesh.polygons: pts = vtk.vtkIdList() polygonPoints = visPolygon.pointIndices for p in polygonPoints: pts.InsertNextId(p) numPoints = len(polygonPoints) if numPoints == 4: vtkgrid.InsertNextCell(quadType, pts) elif numPoints == 3: vtkgrid.InsertNextCell(triangleType, pts) else: vtkgrid.InsertNextCell(polygonType, pts) # # replace any VisIrregularPolyhedron with a list of VisTetrahedron # if visMesh.visVoxels != None: for voxel in visMesh.visVoxels: pts = vtk.vtkIdList() polyhedronPoints = voxel.pointIndices for p in polyhedronPoints: pts.InsertNextId(p) vtkgrid.InsertNextCell(voxelType, pts) if visMesh.tetrahedra != None: for visTet in visMesh.tetrahedra: assert isinstance(visTet, VisTetrahedron) pts = vtk.vtkIdList() tetPoints = visTet.pointIndices for p in tetPoints: pts.InsertNextId(p) vtkgrid.InsertNextCell(tetraType, pts) bInitializedFaces = False if visMesh.irregularPolyhedra != None: for clippedPolyhedron in visMesh.irregularPolyhedra: if bClipPolyhedra == True: tets = createTetrahedra(clippedPolyhedron, visMesh) for visTet in tets: pts = vtk.vtkIdList() tetPoints = visTet.getPointIndices() for p in tetPoints: pts.InsertNextId(p) vtkgrid.InsertNextCell(tetraType, pts) else: faceStreamList = vtk.vtkIdList() faceStream = getVtkFaceStream(clippedPolyhedron) for p in faceStream: faceStreamList.InsertNextId(p) if bInitializedFaces == False and vtkgrid.GetNumberOfCells( ) > 0: vtkgrid.InitializeFacesRepresentation( vtkgrid.GetNumberOfCells()) bInitializedFaces = True vtkgrid.InsertNextCell(polyhedronType, faceStreamList) vtkgrid.BuildLinks() # vtkgrid.Squeeze() return vtkgrid
add_line([0, 0, 0], index_2d_to_3d_det(proj_pt), 0.0, 1.0, 0.0) # Draw the detector plane #add_sphere(det_r0c0, 1, 1, 0, 5.0) #add_sphere(det_r0cN, 1, 146.0/255.0, 20.0/255.0, 5.0) #add_sphere(det_rMc0, 116.0/255.0, 0, 189.0/255.0, 5.0) #add_sphere(det_rMcN, 46.0/255.0, 238.0/255.0, 1, 5.0) det_corners = vtkPoints() det_corners.InsertNextPoint(det_r0c0[0], det_r0c0[1], det_r0c0[2]) det_corners.InsertNextPoint(det_rMc0[0], det_rMc0[1], det_rMc0[2]) det_corners.InsertNextPoint(det_rMcN[0], det_rMcN[1], det_rMcN[2]) det_corners.InsertNextPoint(det_r0cN[0], det_r0cN[1], det_r0cN[2]) det_quad = vtkQuad() det_quad.GetPointIds().SetId(0, 0) det_quad.GetPointIds().SetId(1, 1) det_quad.GetPointIds().SetId(2, 2) det_quad.GetPointIds().SetId(3, 3) quads = vtkCellArray() quads.InsertNextCell(det_quad) det_poly_data = vtkPolyData() det_poly_data.SetPoints(det_corners) det_poly_data.SetPolys(quads) tex_coords = vtkFloatArray() tex_coords.SetNumberOfComponents(2) tex_coords.SetName('TextureCoordinates')
def load_shabp_geometry(self, shabp_filename, name='main', plot=True): self.gui.eid_maps[name] = {} self.gui.nid_maps[name] = {} #key = self.case_keys[self.icase] #case = self.result_cases[key] skip_reading = self.gui._remove_old_geometry(shabp_filename) if skip_reading: return self.model = read_shabp(shabp_filename, log=self.gui.log, debug=self.gui.debug) self.gui.model_type = 'shabp' # model.model_type nodes, elements, patches, components, impact, shadow = self.model.get_points_elements_regions( ) #for nid,node in enumerate(nodes): #print "node[%s] = %s" %(nid,str(node)) nnodes = len(nodes) nelements = len(elements) self.gui.nnodes = nnodes self.gui.nelements = nelements #print("nnodes = ",self.nnodes) #print("nelements = ", self.nelements) grid = self.gui.grid grid.Allocate(nelements, 1000) points = vtk.vtkPoints() points.SetNumberOfPoints(nnodes) assert len(nodes) > 0 mmax = amax(nodes, axis=0) mmin = amin(nodes, axis=0) dim_max = (mmax - mmin).max() self.gui.create_global_axes(dim_max) for nid, node in enumerate(nodes): points.InsertPoint(nid, *node) assert len(elements) > 0 for eid, element in enumerate(elements): (p1, p2, p3, p4) = element elem = vtkQuad() elem.GetPointIds().SetId(0, p1) elem.GetPointIds().SetId(1, p2) elem.GetPointIds().SetId(2, p3) elem.GetPointIds().SetId(3, p4) grid.InsertNextCell(elem.GetCellType(), elem.GetPointIds()) grid.SetPoints(points) grid.Modified() if hasattr(grid, 'Update'): # pragma: no cover grid.Update() # loadShabpResults - regions/loads self.gui.scalar_bar_actor.VisibilityOn() self.gui.scalar_bar_actor.Modified() self.gui.isubcase_name_map = {1: ['S/HABP', '']} cases = OrderedDict() ID = 1 self.gui.log.debug("nNodes=%i nElements=%i" % (self.gui.nnodes, self.gui.nelements)) form, cases = self._fill_shabp_geometry_case(cases, ID, nodes, elements, patches, components, impact, shadow) nelements = len(elements) node_ids = np.arange(1, nnodes + 1, dtype='int32') element_ids = np.arange(1, nelements + 1, dtype='int32') self.gui.node_ids = node_ids self.gui.element_ids = element_ids self.gui._finish_results_io2(form, cases)
def transformLegacySrep(self, m3d_filename, outPrefix, epsilon): print('tranform legacy srep') outputUp = outPrefix + '/up.vtp' outputDown = outPrefix + '/down.vtp' outputCrest = outPrefix + '/crest.vtp' """ The purpose of this part of code is to play around m3d to fit into the new s-rep format framework """ up_spokes_polydata = vtk.vtkPolyData() down_spokes_polydata = vtk.vtkPolyData() crest_spokes_polydata = vtk.vtkPolyData() # read in m3d file s = srep.srep() s.readSrepFromM3D(m3d_filename) writer = vtk.vtkXMLPolyDataWriter() writer.SetDataModeToAscii() """ Given an s-rep, 1. read in medial points 2. set spoke vectors as point data 3. set spoke vector length as point data as well 4. create a header that contains meta data (e.g., number of rows, number of columns, mesh type) 5. create xml header """ nRows = s.fig.numRows nCols = s.fig.numCols # create root = Element('s-rep') nRowsXMLElement = SubElement(root, 'nRows') nRowsXMLElement.text = str(nRows) nColsXMLElement = SubElement(root, 'nCols') nColsXMLElement.text = str(nCols) meshTypeXMLElement = SubElement(root, 'meshType') meshTypeXMLElement.text = 'Quad' colorXMLElement = SubElement(root, 'color') redXMLElement = SubElement(colorXMLElement, 'red') redXMLElement.text = str(0) greenXMLElement = SubElement(colorXMLElement, 'green') greenXMLElement.text = str(0.5) blueXMLElement = SubElement(colorXMLElement, 'blue') blueXMLElement.text = str(0) isMeanFlagXMLElement = SubElement(root, 'isMean') isMeanFlagXMLElement.text = 'False' meanStatPathXMLElement = SubElement(root, 'meanStatPath') meanStatPathXMLElement.text = '' # later this can be done as a parameter upSpokeXMLElement = SubElement(root, 'upSpoke') upSpokeXMLElement.text = os.path.join(outputUp) downSpokeXMLElement = SubElement(root, 'downSpoke') downSpokeXMLElement.text = os.path.join(outputDown) crestSpokeXMLElement = SubElement(root, 'crestSpoke') crestSpokeXMLElement.text = os.path.join(outputCrest) crestShiftXMLElement = SubElement(root, 'crestShift') crestShiftXMLElement.text = str(epsilon) file_handle = open(outPrefix + '/header.xml', 'w') file_handle.write(prettify(root)) file_handle.close() # medial points and polygons first medial_points = vtk.vtkPoints() medial_points.SetDataTypeToDouble( ) # important, this fix the bug that new srep has different precision with legacy one, you can find it by runningapplyTps2NewSrep program medial_polys = vtk.vtkCellArray() # This will be curves crest_points = vtk.vtkPoints() crest_polys = vtk.vtkCellArray() # up_spoke_directions = vtk.vtkDoubleArray() up_spoke_directions.SetNumberOfComponents(3) up_spoke_directions.SetName("spokeDirection") up_spoke_lengths = vtk.vtkDoubleArray() up_spoke_lengths.SetNumberOfComponents(1) up_spoke_lengths.SetName("spokeLength") down_spoke_directions = vtk.vtkDoubleArray() down_spoke_directions.SetNumberOfComponents(3) down_spoke_directions.SetName("spokeDirection") down_spoke_lengths = vtk.vtkDoubleArray() down_spoke_lengths.SetNumberOfComponents(1) down_spoke_lengths.SetName("spokeLength") crest_spoke_directions = vtk.vtkDoubleArray() crest_spoke_directions.SetNumberOfComponents(3) crest_spoke_directions.SetName("spokeDirection") crest_spoke_lengths = vtk.vtkDoubleArray() crest_spoke_lengths.SetNumberOfComponents(1) crest_spoke_lengths.SetName("spokeLength") """ Read in 1. medial points, 2. up spokeLength, up spokeDirection 3. down spokeLength, down spokeDirection """ for r in range(nRows): for c in range(nCols): current_atom = s.fig.atoms[r, c] current_point = current_atom.hub.P current_id = medial_points.InsertNextPoint(current_point) if r < nRows - 1 and c < nCols - 1: quad = vtk.vtkQuad() quad.GetPointIds().SetId(0, current_id) quad.GetPointIds().SetId(1, current_id + nCols) quad.GetPointIds().SetId(2, current_id + nCols + 1) quad.GetPointIds().SetId(3, current_id + 1) medial_polys.InsertNextCell(quad) current_up_spoke = current_atom.topSpoke current_up_spoke_direction = current_up_spoke.U up_spoke_directions.InsertNextTuple(current_up_spoke_direction) current_up_spoke_length = current_up_spoke.r up_spoke_lengths.InsertNextTuple1(current_up_spoke_length) current_down_spoke = current_atom.botSpoke current_down_spoke_direction = current_down_spoke.U down_spoke_directions.InsertNextTuple( current_down_spoke_direction) current_down_spoke_length = current_down_spoke.r down_spoke_lengths.InsertNextTuple1(current_down_spoke_length) """ Construct crest vtp 1. read points, direction, and length in clockwise 2. write it as a curve """ # \TODO: There is a lot repeating of the same code. Need to think if I can abstract the repetition into a function # first row r = 0 for c in range(nCols - 1): current_crest_atom = s.fig.atoms[r, c] current_crest_spoke = current_crest_atom.crestSpoke current_crest_spoke_direction = current_crest_spoke.U current_crest_point = current_crest_atom.hub.P + epsilon * current_crest_spoke_direction current_crest_point_id = crest_points.InsertNextPoint( current_crest_point) line = vtk.vtkLine() if current_crest_point_id > 0: line = vtk.vtkLine() line.GetPointIds().SetId(0, current_crest_point_id - 1) line.GetPointIds().SetId(1, current_crest_point_id) crest_polys.InsertNextCell(line) crest_spoke_directions.InsertNextTuple( current_crest_spoke_direction) current_crest_spoke_length = current_crest_spoke.r crest_spoke_lengths.InsertNextTuple1(current_crest_spoke_length) # last column c = nCols - 1 for r in range(nRows - 1): current_crest_atom = s.fig.atoms[r, c] current_crest_spoke = current_crest_atom.crestSpoke current_crest_spoke_direction = current_crest_spoke.U current_crest_point = current_crest_atom.hub.P + epsilon * current_crest_spoke_direction current_crest_point_id = crest_points.InsertNextPoint( current_crest_point) line = vtk.vtkLine() if current_crest_point_id > 0: line = vtk.vtkLine() line.GetPointIds().SetId(0, current_crest_point_id - 1) line.GetPointIds().SetId(1, current_crest_point_id) crest_polys.InsertNextCell(line) crest_spoke_directions.InsertNextTuple( current_crest_spoke_direction) current_crest_spoke_length = current_crest_spoke.r crest_spoke_lengths.InsertNextTuple1(current_crest_spoke_length) # bottom row r = nRows - 1 for c in range(nCols - 1, 0, -1): current_crest_atom = s.fig.atoms[r, c] current_crest_spoke = current_crest_atom.crestSpoke current_crest_spoke_direction = current_crest_spoke.U current_crest_point = current_crest_atom.hub.P + epsilon * current_crest_spoke_direction current_crest_point_id = crest_points.InsertNextPoint( current_crest_point) line = vtk.vtkLine() if current_crest_point_id > 0: line = vtk.vtkLine() line.GetPointIds().SetId(0, current_crest_point_id - 1) line.GetPointIds().SetId(1, current_crest_point_id) crest_polys.InsertNextCell(line) crest_spoke_directions.InsertNextTuple( current_crest_spoke_direction) current_crest_spoke_length = current_crest_spoke.r crest_spoke_lengths.InsertNextTuple1(current_crest_spoke_length) # first column c = 0 for r in range(nRows - 1, 0, -1): current_crest_atom = s.fig.atoms[r, c] current_crest_spoke = current_crest_atom.crestSpoke current_crest_spoke_direction = current_crest_spoke.U current_crest_point = current_crest_atom.hub.P + epsilon * current_crest_spoke_direction current_crest_point_id = crest_points.InsertNextPoint( current_crest_point) line = vtk.vtkLine() if current_crest_point_id > 0: line = vtk.vtkLine() line.GetPointIds().SetId(0, current_crest_point_id - 1) line.GetPointIds().SetId(1, current_crest_point_id) crest_polys.InsertNextCell(line) crest_spoke_directions.InsertNextTuple( current_crest_spoke_direction) current_crest_spoke_length = current_crest_spoke.r crest_spoke_lengths.InsertNextTuple1(current_crest_spoke_length) # to complete loop line = vtk.vtkLine() line.GetPointIds().SetId(0, current_crest_point_id) line.GetPointIds().SetId(1, 0) crest_polys.InsertNextCell(line) polyLine = vtk.vtkPolyLine() polyLine.GetPointIds().SetNumberOfIds( crest_points.GetNumberOfPoints() + 1) for i in range(crest_points.GetNumberOfPoints()): # polyLine->GetPointIds()->SetId(i, i); polyLine.GetPointIds().SetId(i, i) polyLine.GetPointIds().SetId(crest_points.GetNumberOfPoints(), 0) cells = vtk.vtkCellArray() cells.InsertNextCell(polyLine) crest_spokes_polydata.SetPoints(crest_points) crest_spokes_polydata.SetLines(cells) crest_spokes_polydata.GetPointData().AddArray(crest_spoke_directions) crest_spokes_polydata.GetPointData().SetActiveVectors("spokeDirection") crest_spokes_polydata.GetPointData().AddArray(crest_spoke_lengths) crest_spokes_polydata.GetPointData().SetActiveScalars("spokeLength") writer.SetFileName(outputCrest) writer.SetInputData(crest_spokes_polydata) writer.Update() up_spokes_polydata.SetPoints(medial_points) up_spokes_polydata.SetPolys(medial_polys) up_spokes_polydata.GetPointData().AddArray(up_spoke_directions) up_spokes_polydata.GetPointData().SetActiveVectors("spokeDirection") up_spokes_polydata.GetPointData().AddArray(up_spoke_lengths) up_spokes_polydata.GetPointData().SetActiveScalars("spokeLength") writer.SetFileName(outputUp) writer.SetInputData(up_spokes_polydata) writer.Update() down_spokes_polydata.SetPoints(medial_points) down_spokes_polydata.SetPolys(medial_polys) down_spokes_polydata.GetPointData().AddArray(down_spoke_directions) down_spokes_polydata.GetPointData().SetActiveVectors("spokeDirection") down_spokes_polydata.GetPointData().AddArray(down_spoke_lengths) down_spokes_polydata.GetPointData().SetActiveScalars("spokeLength") writer.SetFileName(outputDown) writer.SetInputData(down_spokes_polydata) writer.Update() print('Finished transformation and save to files:') print(outputUp) print(outputDown) print(outputCrest)
elem.GetPointIds().SetId(3, nidMap[nodeIDs[1]]) elem.GetPointIds().SetId(4, nidMap[nodeIDs[3]]) elem.GetPointIds().SetId(5, nidMap[nodeIDs[5]]) else: elem = vtk.vtkTriangle() elem.GetPointIds().SetId(0, nidMap[nodeIDs[0]]) elem.GetPointIds().SetId(1, nidMap[nodeIDs[2]]) elem.GetPointIds().SetId(2, nidMap[nodeIDs[4]]) Triax6cell = grid.InsertNextCell(elem.GetCellType(), elem.GetPointIds()) Color.InsertTuple1(Triax6cell, 4) elif (isinstance(element, CQUAD4) or isinstance(element, CSHEAR) or isinstance(element, CQUADR)): nodeIDs = element.nodeIDs() elem = vtk.vtkQuad() elem.GetPointIds().SetId(0, nidMap[nodeIDs[0]]) elem.GetPointIds().SetId(1, nidMap[nodeIDs[1]]) elem.GetPointIds().SetId(2, nidMap[nodeIDs[2]]) elem.GetPointIds().SetId(3, nidMap[nodeIDs[3]]) Quad4cell = grid.InsertNextCell(elem.GetCellType(), elem.GetPointIds()) Color.InsertTuple1(Quad4cell, 4) elif isinstance(element, CQUAD8): nodeIDs = element.nodeIDs() if None not in nodeIDs: elem = vtk.vtkQuadraticQuad() elem.GetPointIds().SetId(4, nidMap[nodeIDs[4]]) elem.GetPointIds().SetId(5, nidMap[nodeIDs[5]]) elem.GetPointIds().SetId(6, nidMap[nodeIDs[6]]) elem.GetPointIds().SetId(7, nidMap[nodeIDs[7]])
def setup_renderers(renwin, fg_ren, bg_ren): """Utility method to configure foreground and background renderer and insert them into different layers of the renderenwinindow. Use this if you want an incredibly cool gradient background! """ # bit of code thanks to # http://www.bioengineering-research.com/vtk/BackgroundGradient.tcl # had to change approach though to using background renderer, # else transparent objects don't appear, and adding flat # shaded objects breaks the background gradient. # ================================================================= qpts = vtk.vtkPoints() qpts.SetNumberOfPoints(4) qpts.InsertPoint(0, 0, 0, 0) qpts.InsertPoint(1, 1, 0, 0) qpts.InsertPoint(2, 1, 1, 0) qpts.InsertPoint(3, 0, 1, 0) quad = vtk.vtkQuad() quad.GetPointIds().SetId(0, 0) quad.GetPointIds().SetId(1, 1) quad.GetPointIds().SetId(2, 2) quad.GetPointIds().SetId(3, 3) uc = vtk.vtkUnsignedCharArray() uc.SetNumberOfComponents(4) uc.SetNumberOfTuples(4) uc.SetTuple4(0, 128, 128, 128, 255) # bottom left RGBA uc.SetTuple4(1, 128, 128, 128, 255) # bottom right RGBA uc.SetTuple4(2, 255, 255, 255, 255) # top right RGBA uc.SetTuple4(3, 255, 255, 255, 255) # tob left RGBA dta = vtk.vtkPolyData() dta.Allocate(1, 1) dta.InsertNextCell(quad.GetCellType(), quad.GetPointIds()) dta.SetPoints(qpts) dta.GetPointData().SetScalars(uc) coord = vtk.vtkCoordinate() coord.SetCoordinateSystemToNormalizedDisplay() mapper2d = vtk.vtkPolyDataMapper2D() mapper2d.SetInput(dta) mapper2d.SetTransformCoordinate(coord) actor2d = vtk.vtkActor2D() actor2d.SetMapper(mapper2d) actor2d.GetProperty().SetDisplayLocationToBackground() bg_ren.AddActor(actor2d) bg_ren.SetLayer(0) # seems to be background bg_ren.SetInteractive(0) fg_ren.SetLayer(1) # and foreground renwin.SetNumberOfLayers(2) renwin.AddRenderer(fg_ren) renwin.AddRenderer(bg_ren)
def load_degen_geom_geometry(self, csv_filename, dirname, name='main', plot=True):# pragma: no cover #key = self.case_keys[self.icase] #case = self.result_cases[key] skip_reading = self._remove_old_adb_geometry(csv_filename) if skip_reading: return model = DegenGeom(log=self.log, debug=False) self.model_type = 'vspaero' #self.model_type = model.model_type model.read_degen_geom(csv_filename) for name, comps in sorted(model.components.items()): print('name = %r' % name) #print(comp) print('------------') for comp in comps: nodes = comp.xyz elements = comp.elements nnodes = nodes.shape[0] nelements = elements.shape[0] self.nNodes = nnodes self.nElements = nelements self.grid.Allocate(self.nElements, 1000) #self.gridResult.SetNumberOfComponents(self.nElements) points = vtk.vtkPoints() points.SetNumberOfPoints(self.nNodes) #self.gridResult.Allocate(self.nNodes, 1000) #vectorReselt.SetNumberOfComponents(3) self.nid_map = {} assert nodes is not None nid = 0 #print("nxyz_nodes=%s" % nxyz_nodes) mmax = amax(nodes, axis=0) mmin = amin(nodes, axis=0) dim_max = (mmax - mmin).max() self.create_global_axes(dim_max) for i in range(nnodes): points.InsertPoint(nid, nodes[i, :]) nid += 1 #self.log.info('nxyz_nodes=%s nwake_nodes=%s total=%s' % ( #nnodes, nwake_nodes, nxyz_nodes + nwake_nodes)) #self.log.info('nxyz_elements=%s nwake_elements=%s total=%s' % ( #nxyz_elements, nwake_elements, nxyz_elements + nwake_elements)) elements -= 1 for eid in range(nelements): elem = vtkQuad() #assert elem.GetCellType() == 9, elem.GetCellType() node_ids = elements[eid, :] elem.GetPointIds().SetId(0, node_ids[0]) elem.GetPointIds().SetId(1, node_ids[1]) elem.GetPointIds().SetId(2, node_ids[2]) elem.GetPointIds().SetId(3, node_ids[3]) #elem.GetCellType() = 5 # vtkTriangle self.grid.InsertNextCell(9, elem.GetPointIds()) self.grid.SetPoints(points) self.grid.Modified() if hasattr(self.grid, 'Update'): self.grid.Update() self.log_info("updated grid") # load results - regions/loads self.scalarBar.VisibilityOn() self.scalarBar.Modified() #mach = model.machs[0] #alpha = model.alphas[0] #beta = model.betas[0] #note = ': Mach=%.2f, alpha=%.1f, beta=%.1f' % (mach, alpha, beta) note = 'name=%s' % name self.iSubcaseNameMap = {1: ['OpenVSP%s' % note, '']} cases = {} ID = 1 form, cases = self._fill_degen_geom_case(cases, ID, model, nnodes, nelements) self._finish_results_io2(form, cases)
def load_abaqus_geometry(self, abaqus_filename, dirname, name='main', plot=True): """loads abaqus input files into the gui""" skip_reading = self._remove_old_cart3d_geometry(abaqus_filename) if skip_reading: return self.eid_map = {} self.nid_map = {} model = Abaqus(log=self.log, debug=False) self.model_type = 'abaqus' #self.model_type = model.model_type model.read_abaqus_inp(abaqus_filename) n_r2d2 = 0 n_cpe3 = 0 n_cpe4 = 0 n_cpe4r = 0 n_coh2d4 = 0 n_c3d10h = 0 n_cohax4 = 0 n_cax3 = 0 n_cax4r = 0 nnodes = 0 nelements = 0 all_nodes = [] for part_name, part in iteritems(model.parts): nids = part.nids - 1 nodes = part.nodes nnodes += nodes.shape[0] if part.r2d2 is not None: n_r2d2 += part.r2d2.shape[0] if part.cpe3 is not None: n_cpe3 += part.cpe3.shape[0] if part.cpe4 is not None: n_cpe4 += part.cpe4.shape[0] if part.cpe4r is not None: n_cpe4r += part.cpe4r.shape[0] if part.coh2d4 is not None: n_coh2d4 += part.coh2d4.shape[0] if part.cohax4 is not None: n_cohax4 += part.cohax4.shape[0] if part.cax3 is not None: n_cax3 += part.cax3.shape[0] if part.cax4r is not None: n_cax4r += part.cax4r.shape[0] if part.c3d10h is not None: n_c3d10h += part.c3d10h.shape[0] all_nodes.append(nodes) nelements += n_r2d2 + n_cpe3 + n_cpe4 + n_cpe4r + n_coh2d4 + n_c3d10h + n_cohax4 + n_cax3 + n_cax4r assert nelements > 0, nelements #nodes = model.nodes #elements = model.elements self.nNodes = nnodes self.nElements = nelements self.grid.Allocate(self.nElements, 1000) points = vtk.vtkPoints() points.SetNumberOfPoints(self.nNodes) self.nid_map = {} assert nodes is not None nnodes = nodes.shape[0] if len(all_nodes) == 1: nodes = all_nodes[0] else: nodes = np.vstack(all_nodes) mmax = np.amax(nodes, axis=0) mmin = np.amin(nodes, axis=0) dim_max = (mmax - mmin).max() self.create_global_axes(dim_max) data_type = vtk.VTK_FLOAT points_array = numpy_to_vtk( num_array=nodes, deep=True, array_type=data_type ) points.SetData(points_array) nid_offset = -1 for part_name, part in iteritems(model.parts): nnodesi = part.nodes.shape[0] n_r2d2 = 0 n_cpe3 = 0 n_cpe4 = 0 n_cpe4r = 0 n_coh2d4 = 0 n_c3d10h = 0 n_cohax4 = 0 n_cax3 = 0 n_cax4r = 0 if part.r2d2 is not None: n_r2d2 += part.r2d2.shape[0] if part.cpe3 is not None: n_cpe3 += part.cpe3.shape[0] if part.cpe4 is not None: n_cpe4 += part.cpe4.shape[0] if part.cpe4r is not None: n_cpe4r += part.cpe4r.shape[0] if part.coh2d4 is not None: n_coh2d4 += part.coh2d4.shape[0] if part.cohax4 is not None: n_cohax4 += part.cohax4.shape[0] if part.cax3 is not None: n_cax3 += part.cax3.shape[0] if part.cax4r is not None: n_cax4r += part.cax4r.shape[0] # solids if part.c3d10h is not None: n_c3d10h += part.c3d10h.shape[0] if n_r2d2: eids = part.r2d2[:, 0] node_ids = part.r2d2[:, 1:] + nid_offset for eid, node_ids in zip(eids, node_ids): elem = vtkLine() elem.GetPointIds().SetId(0, node_ids[0]) elem.GetPointIds().SetId(1, node_ids[1]) self.grid.InsertNextCell(elem.GetCellType(), elem.GetPointIds()) if n_cpe3: eids = part.cpe3[:, 0] node_ids = part.cpe3[:, 1:] + nid_offset for eid, node_ids in zip(eids, node_ids): elem = vtkTriangle() elem.GetPointIds().SetId(0, node_ids[0]) elem.GetPointIds().SetId(1, node_ids[1]) elem.GetPointIds().SetId(2, node_ids[2]) self.grid.InsertNextCell(5, elem.GetPointIds()) if n_cpe4: eids = part.cpe4[:, 0] node_ids = part.cpe4[:, 1:] + nid_offset for eid, node_ids in zip(eids, node_ids): elem = vtkQuad() elem.GetPointIds().SetId(0, node_ids[0]) elem.GetPointIds().SetId(1, node_ids[1]) elem.GetPointIds().SetId(2, node_ids[2]) elem.GetPointIds().SetId(3, node_ids[3]) self.grid.InsertNextCell(elem.GetCellType(), elem.GetPointIds()) if n_cpe4r: eids = part.cpe4r[:, 0] node_ids = part.cpe4r[:, 1:] + nid_offset for eid, node_ids in zip(eids, node_ids): elem = vtkQuad() elem.GetPointIds().SetId(0, node_ids[0]) elem.GetPointIds().SetId(1, node_ids[1]) elem.GetPointIds().SetId(2, node_ids[2]) elem.GetPointIds().SetId(3, node_ids[3]) self.grid.InsertNextCell(elem.GetCellType(), elem.GetPointIds()) if n_coh2d4: eids = part.coh2d4[:, 0] node_ids = part.coh2d4[:, 1:] + nid_offset for eid, node_ids in zip(eids, node_ids): elem = vtkQuad() elem.GetPointIds().SetId(0, node_ids[0]) elem.GetPointIds().SetId(1, node_ids[1]) elem.GetPointIds().SetId(2, node_ids[2]) elem.GetPointIds().SetId(3, node_ids[3]) self.grid.InsertNextCell(elem.GetCellType(), elem.GetPointIds()) if n_cohax4: eids = part.cohax4[:, 0] node_ids = part.cohax4[:, 1:] + nid_offset for eid, node_ids in zip(eids, node_ids): elem = vtkQuad() elem.GetPointIds().SetId(0, node_ids[0]) elem.GetPointIds().SetId(1, node_ids[1]) elem.GetPointIds().SetId(2, node_ids[2]) elem.GetPointIds().SetId(3, node_ids[3]) self.grid.InsertNextCell(elem.GetCellType(), elem.GetPointIds()) if n_cax3: eids = part.cax3[:, 0] node_ids = part.cax3[:, 1:] + nid_offset for eid, node_ids in zip(eids, node_ids): elem = vtkTriangle() elem.GetPointIds().SetId(0, node_ids[0]) elem.GetPointIds().SetId(1, node_ids[1]) elem.GetPointIds().SetId(2, node_ids[2]) self.grid.InsertNextCell(5, elem.GetPointIds()) if n_cax4r: eids = part.cax4r[:, 0] node_ids = part.cax4r[:, 1:] + nid_offset for eid, node_ids in zip(eids, node_ids): elem = vtkQuad() elem.GetPointIds().SetId(0, node_ids[0]) elem.GetPointIds().SetId(1, node_ids[1]) elem.GetPointIds().SetId(2, node_ids[2]) elem.GetPointIds().SetId(3, node_ids[3]) self.grid.InsertNextCell(elem.GetCellType(), elem.GetPointIds()) # solids if n_c3d10h: eids = part.c3d10h[:, 0] node_ids = part.c3d10h[:, 1:] + nid_offset for eid, node_ids in zip(eids, node_ids): #for eid, node_ids in part.c3d10h: elem = vtkTetra() elem.GetPointIds().SetId(0, node_ids[0]) elem.GetPointIds().SetId(1, node_ids[1]) elem.GetPointIds().SetId(2, node_ids[2]) elem.GetPointIds().SetId(3, node_ids[3]) self.grid.InsertNextCell(elem.GetCellType(), elem.GetPointIds()) nid_offset += nnodesi self.grid.SetPoints(points) self.grid.Modified() if hasattr(self.grid, 'Update'): self.grid.Update() # loadCart3dResults - regions/loads #self.turn_text_on() self.scalarBar.VisibilityOn() self.scalarBar.Modified() note = '' self.iSubcaseNameMap = {1: ['Abaqus%s' % note, '']} #form = [] cases = {} ID = 1 form, cases, icase = self._fill_abaqus_case(cases, ID, nodes, nelements, model) #self._fill_cart3d_results(cases, form, icase, ID, model) self._finish_results_io2(form, cases)
def load_su2_geometry(self, su2_filename, name='main', plot=True): #print("load_su2_geometry...") skip_reading = self._remove_old_geometry(su2_filename) if skip_reading: return model = SU2(log=self.log, debug=False) #self.model_type = model.model_type ndim, nodes, elements, regions = model.read_su2(su2_filename) nnodes = nodes.shape[0] nelements = 0 for etype, elems in iteritems(elements): nsub_elements = elems.shape[0] if nsub_elements: nelements += nsub_elements #print('min of type = %s' % elems.min()) assert nnodes > 0, nnodes assert nelements > 0, nelements self.nnodes = nnodes self.nelements = nelements self.log.info('nnodes=%s nelements=%s' % (self.nnodes, self.nelements)) self.grid.Allocate(self.nelements, 1000) self.nid_map = {} assert nodes is not None nnodes = nodes.shape[0] if ndim == 3: xmax, ymax, zmax = nodes.max(axis=0) xmin, ymin, zmin = nodes.min(axis=0) self.log.info('xmax=%s xmin=%s' % (xmax, xmin)) self.log.info('ymax=%s ymin=%s' % (ymax, ymin)) self.log.info('zmax=%s zmin=%s' % (zmax, zmin)) dim_max = max(xmax - xmin, ymax - ymin, zmax - zmin) elif ndim == 2: xmax, ymax = nodes.max(axis=0) xmin, ymin = nodes.min(axis=0) self.log.info('xmax=%s xmin=%s' % (xmax, xmin)) self.log.info('ymax=%s ymin=%s' % (ymax, ymin)) dim_max = max(xmax - xmin, ymax - ymin) self.create_global_axes(dim_max) if ndim == 2: nodes = np.hstack( [nodes, np.zeros((nnodes, 1), dtype=nodes.dtype)]) #else: # ndim=3 points = numpy_to_vtk_points(nodes) #nelements = 0 #elements = { #5 : tris, #9 : quads, #} #print('dict =', elements) for etype, elems in iteritems(elements): #print(etype, elems) if isinstance(elems, list): #print('continue') continue #print(type(elems)) nsub_elements = elems.shape[0] if nsub_elements == 0: #print('continue') continue #print('eid_min =', elems.min()) assert nsub_elements > 0, nsub_elements if etype == 5: for eid in range(nsub_elements): elem = vtkTriangle() node_ids = elems[eid, :] elem.GetPointIds().SetId(0, node_ids[0]) elem.GetPointIds().SetId(1, node_ids[1]) elem.GetPointIds().SetId(2, node_ids[2]) self.grid.InsertNextCell(5, elem.GetPointIds( )) #elem.GetCellType() = 5 # vtkTriangle elif etype == 9: for eid in range(nsub_elements): elem = vtk.vtkQuad() node_ids = elems[eid, :] elem.GetPointIds().SetId(0, node_ids[0]) elem.GetPointIds().SetId(1, node_ids[1]) elem.GetPointIds().SetId(2, node_ids[2]) elem.GetPointIds().SetId(3, node_ids[3]) self.grid.InsertNextCell(elem.GetCellType(), elem.GetPointIds()) else: raise NotImplementedError(etype) self.grid.SetPoints(points) self.grid.Modified() if hasattr(self.grid, 'Update'): self.grid.Update() self.log_info("updated grid") # loadSTLResults - regions/loads self.scalarBar.VisibilityOff() self.scalarBar.Modified() cases = {} self.isubcase_name_map = {} ID = 1 form, cases = self._fill_su2_case(cases, ID, nelements, nnodes) self._finish_results_io2(form, cases)
def load_plot3d_geometry(self, p3d_filename, dirname, name='main'): print("load_plot3d_geometry") self.nid_map = {} #key = self.case_keys[self.icase] #case = self.result_cases[key] skip_reading = self.removeOldGeometry(p3d_filename) if skip_reading: return model = Plot3d(log=self.log, debug=self.debug) #self.model_type = model.model_type model.read_plot3d(p3d_filename) npoints = 0 nelements = 0 for iblock, shape in sorted(iteritems(model.block_shapes)): npoints += shape[0] * shape[1] * shape[2] nelements += (shape[0] - 1) * (shape[1] - 1) * (shape[2] - 1) nblocks = iblock self.nNodes = npoints self.nElements = nelements #nodes, elements, regions = model.getPointsElementsRegions() #for nid,node in enumerate(nodes): #print "node[%s] = %s" %(nid,str(node)) self.grid.Allocate(self.nElements, 1000) points = vtk.vtkPoints() points.SetNumberOfPoints(self.nNodes) nid = 0 nid_base = 0 eid_base = 0 elem = vtkQuad() quad_type = elem.GetCellType() #nblocks = len(model.x) for iblock in range(nblocks): print("iblock =", iblock) nid_base = nid x = model.x[iblock] y = model.y[iblock] z = model.z[iblock] print("x.shape[%s] =" % iblock, x.shape) print(x) (ni, nj, nk) = x.shape assert nk == 1 for k in range(nk): for j in range(nj): for i in range(ni): points.InsertPoint(nid, x[i, j, 0], y[i, j, 0], z[i, j, 0]) nid += 1 for j in range(nj - 1): jstart = nid_base + j * ni for i in range(ni - 1): elem = vtkQuad() p1 = jstart + (i) p2 = jstart + (i + 1) p3 = jstart + (ni) + (i + 1) p4 = jstart + (ni) + (i) elem.GetPointIds().SetId(0, p1) elem.GetPointIds().SetId(1, p2) elem.GetPointIds().SetId(2, p3) elem.GetPointIds().SetId(3, p4) element = [p1, p2, p3, p4] self.grid.InsertNextCell(quad_type, elem.GetPointIds()) print(element) #jstart += ni #nid_base += ni * nj * nk eid_base += (ni-1) * (nj-1) * (nk-1) break #print("eid = ", eid) self.grid.SetPoints(points) #print dir(self.grid) #.SetNumberOfComponents(0) #self.grid.GetCellData().SetNumberOfTuples(1); #self.grid.GetCellData().SetScalars(self.gridResult) self.grid.Modified() self.grid.Update() print("updated grid") #return # loadCart3dResults - regions/loads self. turn_text_on() self.scalarBar.VisibilityOn() self.scalarBar.Modified() self.iSubcaseNameMap = {1: ['Plot3d', '']} cases = {} ID = 1 #cases = self._fill_stl_case(cases, ID, elements) #self.finish_io() self.result_cases = cases self.case_keys = sorted(cases.keys()) #print "case_keys = ",self.case_keys #print "type(case_keys) = ",type(self.case_keys) self.ncases = min(0, len(self.result_cases) - 1) # number of keys in dictionary self.icase = 0 if self.ncases == 0 else -1 self.cycle_results() # start at nCase=0
def _make_tecplot_geometry(self, model, quads_only=False): nodes = model.xyz nnodes = self.nNodes points = vtk.vtkPoints() points.SetNumberOfPoints(nnodes) #self.gridResult.Allocate(self.nNodes, 1000) #vectorReselt.SetNumberOfComponents(3) #self.nid_map = {} #elem.SetNumberOfPoints(nNodes) #assert nodes is not None #nnodes = nodes.shape[0] mmax = amax(nodes, axis=0) mmin = amin(nodes, axis=0) dim_max = (mmax - mmin).max() self.create_global_axes(dim_max) for i in range(nnodes): points.InsertPoint(i, nodes[i, :]) #elements = model.elements quads = model.quad_elements hexas = model.hexa_elements tets = model.tet_elements tris = model.tri_elements is_quads = len(quads) is_tris = len(tris) is_hexas = len(hexas) is_tets = len(tets) is_shells = is_quads + is_tris is_solids = is_tets + is_hexas if is_shells: is_surface = True self._create_tecplot_shells(is_quads, quads, is_tris, tris) elif is_solids: if 0: tris, quads = model.skin_elements() is_tris = bool(len(tris)) is_quads = bool(len(quads)) self._create_tecplot_shells(is_quads, quads, is_tris, tris) else: if is_tets: elements = tets is_surface = False self.nElements = model.nelements self.grid.Allocate(self.nElements, 1000) nelements = elements.shape[0] for eid in range(nelements): elem = vtkTetra() node_ids = elements[eid, :] epoints = elem.GetPointIds() epoints.SetId(0, node_ids[0]) epoints.SetId(1, node_ids[1]) epoints.SetId(2, node_ids[2]) epoints.SetId(3, node_ids[3]) self.grid.InsertNextCell( elem.GetCellType(), elem.GetPointIds( )) #elem.GetCellType() = 5 # vtkTriangle if is_hexas: elements = hexas is_surface = True # is_surface = False is_volume = not is_surface if is_surface: self.nElements = model.nelements free_faces = array(model.get_free_faces(), dtype='int32') # + 1 nfaces = len(free_faces) elements = free_faces self.grid.Allocate(nfaces, 1000) for face in free_faces: elem = vtkQuad() epoints = elem.GetPointIds() epoints.SetId(0, face[0]) epoints.SetId(1, face[1]) epoints.SetId(2, face[2]) epoints.SetId(3, face[3]) self.grid.InsertNextCell( elem.GetCellType(), elem.GetPointIds( )) #elem.GetCellType() = 5 # vtkTriangle elif is_volume: self.nElements = model.nelements self.grid.Allocate(self.nElements, 1000) nelements = elements.shape[0] for eid in range(nelements): elem = vtkHexahedron() node_ids = elements[eid, :] epoints = elem.GetPointIds() epoints.SetId(0, node_ids[0]) epoints.SetId(1, node_ids[1]) epoints.SetId(2, node_ids[2]) epoints.SetId(3, node_ids[3]) epoints.SetId(4, node_ids[4]) epoints.SetId(5, node_ids[5]) epoints.SetId(6, node_ids[6]) epoints.SetId(7, node_ids[7]) self.grid.InsertNextCell( elem.GetCellType(), elem.GetPointIds( )) #elem.GetCellType() = 5 # vtkTriangle else: raise NotImplementedError() self.grid.SetPoints(points) #self.grid.GetPointData().SetScalars(self.gridResult) #print(dir(self.grid) #.SetNumberOfComponents(0)) #self.grid.GetCellData().SetNumberOfTuples(1); #self.grid.GetCellData().SetScalars(self.gridResult) self.grid.Modified() if hasattr(self.grid, 'Update'): self.grid.Update() return is_surface
def load_surf_geometry(self, surf_filename, dirname, plot=True): #skip_reading = self.remove_old_openfoam_geometry(openfoam_filename) #if skip_reading: # return model = SurfReader() self.model_type = 'surf' print('surf_filename = %s' % surf_filename) model.read_surf(surf_filename) nnodes = model.nodes.shape[0] ntris = model.tris.shape[0] nquads = model.quads.shape[0] nelements = ntris + nquads nodes = model.nodes self.nElements = nelements self.nNodes = nnodes print("nNodes = %s" % self.nNodes) print("nElements = %s" % self.nElements) assert nelements > 0, nelements self.grid.Allocate(self.nElements, 1000) points = vtk.vtkPoints() points.SetNumberOfPoints(self.nNodes) mmax = amax(nodes, axis=0) mmin = amin(nodes, axis=0) dim_max = (mmax - mmin).max() self.create_global_axes(dim_max) self.log.info('max = %s' % mmax) self.log.info('min = %s' % mmin) for inode, node in enumerate(nodes): points.InsertPoint(inode, node) tris = model.tris - 1 quads = model.quads - 1 if ntris: for eid, element in enumerate(tris): elem = vtkTriangle() elem.GetPointIds().SetId(0, element[0]) elem.GetPointIds().SetId(1, element[1]) elem.GetPointIds().SetId(2, element[2]) self.grid.InsertNextCell(elem.GetCellType(), elem.GetPointIds()) if nquads: for eid, element in enumerate(quads): elem = vtkQuad() elem.GetPointIds().SetId(0, element[0]) elem.GetPointIds().SetId(1, element[1]) elem.GetPointIds().SetId(2, element[2]) elem.GetPointIds().SetId(3, element[3]) self.grid.InsertNextCell(elem.GetCellType(), elem.GetPointIds()) model.read_surf_failnode(surf_filename) if len(model.nodes_failed): if 'failed_nodes' not in self.alt_grids: yellow = (1., 1., 0.) self.create_alternate_vtk_grid('failed_nodes', color=yellow, line_width=3, opacity=1.0) ifailed = where(model.nodes_failed == 1)[0] nfailed = len(ifailed) self.alt_grids['failed_nodes'].Allocate(nfailed, 1000) grid2 = self.alt_grids['failed_nodes'] points2 = vtk.vtkPoints() points2.SetNumberOfPoints(nfailed) for j, nid in enumerate(model.nodes_failed): elem = vtk.vtkVertex() c = nodes[nid - 1, :] print(nid, c) points2.InsertPoint(j, *c) elem.GetPointIds().SetId(0, j) self.alt_grids['failed_nodes'].InsertNextCell(elem.GetCellType(), elem.GetPointIds()) self.alt_grids['failed_nodes'].SetPoints(points2) self._add_alt_actors(self.alt_grids) actor = self.geometry_actors['failed_nodes'] actor.Modified() prop = actor.GetProperty() prop.SetRepresentationToPoints() prop.SetPointSize(10) # self. self.nElements = nelements self.grid.SetPoints(points) self.grid.Modified() if hasattr(self.grid, 'Update'): self.grid.Update() #print("updated grid") # loadCart3dResults - regions/loads self. turn_text_on() self.scalarBar.VisibilityOn() self.scalarBar.Modified() self.iSubcaseNameMap = {1: ['AFLR Surface', '']} cases = {} ID = 1 form, cases = self._fill_surf_case(surf_filename, cases, ID, nnodes, nelements, model) if plot: self._finish_results_io2(form, cases)
def load_plot3d_geometry(self, p3d_filename, name='main'): print("load_plot3d_geometry") self.nid_map = {} #key = self.case_keys[self.icase] #case = self.result_cases[key] skip_reading = self._remove_old_geometry(p3d_filename) if skip_reading: return model = Plot3d(log=self.log, debug=self.debug) #self.model_type = model.model_type model.read_plot3d(p3d_filename) npoints = 0 nelements = 0 for iblock, shape in sorted(iteritems(model.block_shapes)): npoints += shape[0] * shape[1] * shape[2] nelements += (shape[0] - 1) * (shape[1] - 1) * (shape[2] - 1) nblocks = len(model.block_shapes) self.nnodes = npoints self.nelements = nelements #nodes, elements, regions = model.getPointsElementsRegions() #for nid,node in enumerate(nodes): #print "node[%s] = %s" %(nid,str(node)) self.grid.Allocate(self.nelements, 1000) points = vtk.vtkPoints() points.SetNumberOfPoints(self.nnodes) nid = 0 nid_base = 0 eid_base = 0 elem = vtkQuad() quad_type = elem.GetCellType() #nblocks = len(model.x) for iblock in range(nblocks): print("iblock =", iblock) nid_base = nid x = model.x[iblock] y = model.y[iblock] z = model.z[iblock] print("x.shape[%s] =" % iblock, x.shape) print(x) (ni, nj, nk) = x.shape assert nk == 1 for k in range(nk): for j in range(nj): for i in range(ni): points.InsertPoint( nid, x[i, j, 0], y[i, j, 0], z[i, j, 0]) nid += 1 for j in range(nj - 1): jstart = nid_base + j * ni for i in range(ni - 1): elem = vtkQuad() p1 = jstart + (i) p2 = jstart + (i + 1) p3 = jstart + (ni) + (i + 1) p4 = jstart + (ni) + (i) elem.GetPointIds().SetId(0, p1) elem.GetPointIds().SetId(1, p2) elem.GetPointIds().SetId(2, p3) elem.GetPointIds().SetId(3, p4) element = [p1, p2, p3, p4] self.grid.InsertNextCell(quad_type, elem.GetPointIds()) print(element) #jstart += ni #nid_base += ni * nj * nk eid_base += (ni-1) * (nj-1) * (nk-1) break #print("eid = ", eid) self.grid.SetPoints(points) #print dir(self.grid) #.SetNumberOfComponents(0) #self.grid.GetCellData().SetNumberOfTuples(1); #self.grid.GetCellData().SetScalars(self.gridResult) self.grid.Modified() self.grid.Update() self.log_info("updated grid") #return # loadPlot3dResults - regions/loads self.scalarBar.VisibilityOn() self.scalarBar.Modified() self.isubcase_name_map = {1: ['Plot3d', '']} cases = {} ID = 1 #cases = self._fill_stl_case(cases, ID, elements) #self.finish_io() self.result_cases = cases self.case_keys = sorted(cases.keys()) #print "case_keys = ",self.case_keys #print "type(case_keys) = ",type(self.case_keys) self.ncases = min(0, len(self.result_cases) - 1) # number of keys in dictionary self.icase = 0 if self.ncases == 0 else -1 self.cycle_results() # start at ncase=0
def _make_tecplot_geometry(self, model, quads_only=False): nodes = model.xyz nnodes = self.nNodes points = vtk.vtkPoints() points.SetNumberOfPoints(nnodes) #self.gridResult.Allocate(self.nNodes, 1000) #vectorReselt.SetNumberOfComponents(3) #self.nidMap = {} #elem.SetNumberOfPoints(nNodes) #assert nodes is not None #nnodes = nodes.shape[0] mmax = amax(nodes, axis=0) mmin = amin(nodes, axis=0) dim_max = (mmax - mmin).max() self.update_axes_length(dim_max) for i in range(nnodes): points.InsertPoint(i, nodes[i, :]) #elements = model.elements quads = model.quad_elements hexas = model.hexa_elements tets = model.tet_elements tris = model.tri_elements is_quads = len(quads) is_tris = len(tris) is_hexas = len(hexas) is_tets = len(tets) is_shells = is_quads + is_tris is_solids = is_tets + is_hexas if is_shells: is_surface = True self.self._create_tecplot_shells(is_quads, quads, is_tris, tris) elif is_solids: if 0: tris, quads = model.skin_elements() is_tris = bool(len(tris)) is_quads = bool(len(quads)) self.self._create_tecplot_shells(is_quads, quads, is_tris, tris) else: if is_tets: elements = tets is_surface = False self.nElements = model.nelements self.grid.Allocate(self.nElements, 1000) nelements = elements.shape[0] for eid in range(nelements): elem = vtkTetra() node_ids = elements[eid, :] epoints = elem.GetPointIds() epoints.SetId(0, node_ids[0]) epoints.SetId(1, node_ids[1]) epoints.SetId(2, node_ids[2]) epoints.SetId(3, node_ids[3]) self.grid.InsertNextCell(elem.GetCellType(), elem.GetPointIds()) #elem.GetCellType() = 5 # vtkTriangle if is_hexas: elements = hexas is_surface = True # is_surface = False is_volume = not is_surface if is_surface: self.nElements = model.nelements free_faces = array(model.get_free_faces(), dtype='int32')# + 1 nfaces = len(free_faces) elements = free_faces self.grid.Allocate(nfaces, 1000) for face in free_faces: elem = vtkQuad() epoints = elem.GetPointIds() epoints.SetId(0, face[0]) epoints.SetId(1, face[1]) epoints.SetId(2, face[2]) epoints.SetId(3, face[3]) self.grid.InsertNextCell(elem.GetCellType(), elem.GetPointIds()) #elem.GetCellType() = 5 # vtkTriangle elif is_volume: self.nElements = model.nelements self.grid.Allocate(self.nElements, 1000) nelements = elements.shape[0] for eid in range(nelements): elem = vtkHexahedron() node_ids = elements[eid, :] epoints = elem.GetPointIds() epoints.SetId(0, node_ids[0]) epoints.SetId(1, node_ids[1]) epoints.SetId(2, node_ids[2]) epoints.SetId(3, node_ids[3]) epoints.SetId(4, node_ids[4]) epoints.SetId(5, node_ids[5]) epoints.SetId(6, node_ids[6]) epoints.SetId(7, node_ids[7]) self.grid.InsertNextCell(elem.GetCellType(), elem.GetPointIds()) #elem.GetCellType() = 5 # vtkTriangle else: raise NotImplementedError() self.grid.SetPoints(points) #self.grid.GetPointData().SetScalars(self.gridResult) #print(dir(self.grid) #.SetNumberOfComponents(0)) #self.grid.GetCellData().SetNumberOfTuples(1); #self.grid.GetCellData().SetScalars(self.gridResult) self.grid.Modified() if hasattr(self.grid, 'Update'): self.grid.Update() return is_surface
def find_2d_intersected_cells(intersecting_planes, parent_bit_mask, parent_id, origin, \ spacing, ndims, chunk_info, grid_desc): append = vtk.vtkAppendFilter() append.MergePointsOn() a1 = spacing[0]/2.0 a2 = spacing[1]/2.0 index = 1 for j in range(ndims[1]-1): p2 = a2 + origin[1] + j*spacing[1] for i in range(ndims[0]-1): p1 = a1 + origin[0] + i*spacing[0] for plane in intersecting_planes: n1 = plane["nx"] n2 = plane["ny"] n3 = plane["nz"] p01 = plane["px"] p02 = plane["py"] p03 = plane["pz"] d = math.fabs(n1*(p1-p01) + n2*(p2-p02) + n3*(-p03)) rhs = a1*math.fabs(n1) + a2*math.fabs(n2) if d < rhs or math.fabs(d-rhs) < 0.000001: ug = vtk.vtkUnstructuredGrid() points = vtk.vtkPoints() for pj in range(2): j_offset = pj*spacing[1] for pi in range(2): points.InsertNextPoint(p1 - a1 + pi*spacing[0], \ p2 - a2 + j_offset, \ 0.0) ug.SetPoints(points) quad = vtk.vtkQuad() quad.GetPointIds().SetId(0, 0) quad.GetPointIds().SetId(1, 1) quad.GetPointIds().SetId(2, 3) quad.GetPointIds().SetId(3, 2) ug.InsertNextCell(quad.GetCellType(), quad.GetPointIds()) gids = vtk.vtkIdTypeArray() gids.SetName("GlobalIds") if parent_id == 0: Dx = grid_desc["create_grid"][1]["Cx"] xc = range(chunk_info["x"][0], chunk_info["x"][1]+1) yc = range(chunk_info["y"][0], chunk_info["y"][1]+1) yindex = (yc[j]-1)*Dx gids.InsertNextTuple1(xc[i]+yindex) else: if parent_bit_mask == -1: gids.InsertNextTuple1(parent_id) else: gids.InsertNextTuple1(index*(2**parent_bit_mask) + parent_id) ug.GetCellData().AddArray(gids) ug.GetCellData().SetActiveGlobalIds("GlobalIds") append.AddInputData(ug) break index += 1 if append.GetInputList().GetNumberOfItems(): append.Update() return append.GetOutput() else: return None
def load_shabp_geometry(self, shabpFilename, dirname, name='main', plot=True): self.nid_map = {} #key = self.case_keys[self.icase] #case = self.result_cases[key] skip_reading = self.removeOldGeometry(shabpFilename) if skip_reading: return self.model = SHABP(log=self.log, debug=self.debug) self.model_type = 'shabp' # model.model_type self.model.read_shabp(shabpFilename) nodes, elements, patches, components, impact, shadow = self.model.getPointsElementsRegions() #for nid,node in enumerate(nodes): #print "node[%s] = %s" %(nid,str(node)) self.nNodes = len(nodes) self.nElements = len(elements) #print("nNodes = ",self.nNodes) #print("nElements = ", self.nElements) self.grid.Allocate(self.nElements, 1000) #self.gridResult.SetNumberOfComponents(self.nElements) points = vtk.vtkPoints() points.SetNumberOfPoints(self.nNodes) #self.gridResult.Allocate(self.nNodes, 1000) #vectorReselt.SetNumberOfComponents(3) #elem.SetNumberOfPoints(nNodes) if 0: fraction = 1. / nNodes # so you can color the nodes by ID for nid, node in sorted(iteritems(nodes)): points.InsertPoint(nid - 1, *node) self.gridResult.InsertNextValue(nid * fraction) #print str(element) #elem = vtk.vtkVertex() #elem.GetPointIds().SetId(0, i) #self.aQuadGrid.InsertNextCell(elem.GetCellType(), elem.GetPointIds()) #vectorResult.InsertTuple3(0, 0.0, 0.0, 1.0) assert len(nodes) > 0 mmax = amax(nodes, axis=0) mmin = amin(nodes, axis=0) dim_max = (mmax - mmin).max() self.create_global_axes(dim_max) for nid, node in enumerate(nodes): points.InsertPoint(nid, *node) assert len(elements) > 0 for eid, element in enumerate(elements): (p1, p2, p3, p4) = element #print "element = ",element elem = vtkQuad() elem.GetPointIds().SetId(0, p1) elem.GetPointIds().SetId(1, p2) elem.GetPointIds().SetId(2, p3) elem.GetPointIds().SetId(3, p4) self.grid.InsertNextCell(elem.GetCellType(), elem.GetPointIds()) #print("eid = ", eid) self.grid.SetPoints(points) #self.grid.GetPointData().SetScalars(self.gridResult) #print dir(self.grid) #.SetNumberOfComponents(0) #self.grid.GetCellData().SetNumberOfTuples(1); #self.grid.GetCellData().SetScalars(self.gridResult) self.grid.Modified() if hasattr(self.grid, 'Update'): self.grid.Update() # loadCart3dResults - regions/loads self. turn_text_on() self.scalarBar.VisibilityOn() self.scalarBar.Modified() self.iSubcaseNameMap = {1: ['S/HABP', '']} cases = {} ID = 1 self.log.debug("nNodes=%i nElements=%i" % (self.nNodes, self.nElements)) form, cases = self._fill_shabp_geometry_case(cases, ID, nodes, elements, patches, components, impact, shadow) self._finish_results_io2(form, cases)
def load_panair_geometry(self, panairFileName, dirname): self.nidMap = {} #key = self.caseKeys[self.iCase] #case = self.resultCases[key] skipReading = self.removeOldGeometry(panairFileName) if skipReading: return model = PanairGrid(panairFileName, log=self.log, debug=self.debug) self.modelType = model.modelType model.read_panair() nodes, elements, regions = model.getPointsElementsRegions() #for nid,node in enumerate(nodes): #print "node[%s] = %s" %(nid,str(node)) self.nNodes = len(nodes) self.nElements = len(elements) #print("nNodes = ",self.nNodes) print("nElements = ", self.nElements) self.grid.Allocate(self.nElements, 1000) #self.gridResult.SetNumberOfComponents(self.nElements) self.grid2.Allocate(1, 1000) points = vtk.vtkPoints() points.SetNumberOfPoints(self.nNodes) #self.gridResult.Allocate(self.nNodes, 1000) #vectorReselt.SetNumberOfComponents(3) #elem.SetNumberOfPoints(nNodes) if 0: fraction = 1. / nNodes # so you can color the nodes by ID for nid, node in sorted(nodes.iteritems()): points.InsertPoint(nid - 1, *point) self.gridResult.InsertNextValue(nid * fraction) #print str(element) #elem = vtk.vtkVertex() #elem.GetPointIds().SetId(0, i) #self.aQuadGrid.InsertNextCell(elem.GetCellType(), elem.GetPointIds()) #vectorResult.InsertTuple3(0, 0.0, 0.0, 1.0) for nid, node in enumerate(nodes): points.InsertPoint(nid, *node) #print "nid = ",nid for eid, element in enumerate(elements): (p1, p2, p3, p4) = element #print "element = ",element elem = vtkQuad() elem.GetPointIds().SetId(0, p1) elem.GetPointIds().SetId(1, p2) elem.GetPointIds().SetId(2, p3) elem.GetPointIds().SetId(3, p4) self.grid.InsertNextCell(elem.GetCellType(), elem.GetPointIds()) print("eid = ", eid) self.grid.SetPoints(points) #self.grid2.SetPoints(points2) #self.grid.GetPointData().SetScalars(self.gridResult) #print dir(self.grid) #.SetNumberOfComponents(0) #self.grid.GetCellData().SetNumberOfTuples(1); #self.grid.GetCellData().SetScalars(self.gridResult) self.grid.Modified() self.grid2.Modified() self.grid.Update() self.grid2.Update() print("updated grid") #return # loadCart3dResults - regions/loads self.TurnTextOn() self.scalarBar.VisibilityOn() self.scalarBar.Modified() self.iSubcaseNameMap = {1: ['Panair', '']} cases = {} ID = 1 #print "nElements = ",nElements loads = [] cases = self.fillPanairGeometryCase(cases, ID, nodes, elements, regions, loads) self.resultCases = cases self.caseKeys = sorted(cases.keys()) print "caseKeys = ", self.caseKeys #print "type(caseKeys) = ",type(self.caseKeys) self.iCase = -1 self.nCases = len( self.resultCases) #- 1 # number of keys in dictionary if self.nCases > 1: self.nCases -= 1 self.cycleResults() # start at nCase=0
def load_lawgs_geometry(self, lawgsFileName, dirname, name='main', plot=True): #key = self.case_keys[self.icase] #case = self.result_cases[key] skip_reading = self._remove_old_geometry(lawgsFileName) if skip_reading: return model = LaWGS(lawgsFileName) self.model_type = model.model_type model.readLaWGS() nodes, elements, regions = model.get_points_elements_regions() self.nNodes = len(nodes) self.nElements = len(elements) nodes = array(nodes, dtype='float32') elements = array(elements, dtype='int32') #print("nNodes = ",self.nNodes) #print("nElements = ", self.nElements) self.grid.Allocate(self.nElements, 1000) #self.gridResult.SetNumberOfComponents(self.nElements) points = vtk.vtkPoints() points.SetNumberOfPoints(self.nNodes) #self.gridResult.Allocate(self.nNodes, 1000) #vectorReselt.SetNumberOfComponents(3) self.nid_map = {} #elem.SetNumberOfPoints(nNodes) if 0: fraction = 1. / self.nNodes # so you can color the nodes by ID for nid, node in sorted(iteritems(nodes)): points.InsertPoint(nid - 1, *node) self.gridResult.InsertNextValue(nid * fraction) #print(str(element)) #elem = vtk.vtkVertex() #elem.GetPointIds().SetId(0, i) #self.aQuadGrid.InsertNextCell(elem.GetCellType(), elem.GetPointIds()) #vectorResult.InsertTuple3(0, 0.0, 0.0, 1.0) assert len(nodes) > 0, len(nodes) assert len(elements) > 0, len(elements) for nid, node in enumerate(nodes): points.InsertPoint(nid, *node) elem = vtkQuad() etype = elem.GetCellType() for eid, element in enumerate(elements): (p1, p2, p3, p4) = element elem = vtkQuad() pts = elem.GetPointIds() pts.SetId(0, p1) pts.SetId(1, p2) pts.SetId(2, p3) pts.SetId(3, p4) self.grid.InsertNextCell(etype, elem.GetPointIds()) self.grid.SetPoints(points) #self.grid.GetPointData().SetScalars(self.gridResult) #print(dir(self.grid) #.SetNumberOfComponents(0)) #self.grid.GetCellData().SetNumberOfTuples(1); #self.grid.GetCellData().SetScalars(self.gridResult) self.grid.Modified() if hasattr(self.grid, 'Update'): self.grid.Update() # loadCart3dResults - regions/loads #self. turn_text_on() #self.scalarBar.VisibilityOn() #self.scalarBar.Modified() self.iSubcaseNameMap = {1: ['LaWGS', '']} cases = {} ID = 1 #print("nElements = %s" % nElements) form, cases = self._fill_lawgs_case(cases, ID, nodes, elements, regions) self._finish_results_io2(form, cases)
def _make_tecplot_geometry(self, model, quads_only=False): nodes = model.xyz nnodes = self.nnodes grid = self.grid #points = vtk.vtkPoints() #points.SetNumberOfPoints(nnodes) #self.gridResult.Allocate(self.nnodes, 1000) #vectorReselt.SetNumberOfComponents(3) #self.nid_map = {} #elem.SetNumberOfPoints(nNodes) #assert nodes is not None #nnodes = nodes.shape[0] mmax = amax(nodes, axis=0) mmin = amin(nodes, axis=0) dim_max = (mmax - mmin).max() self.create_global_axes(dim_max) points = numpy_to_vtk_points(nodes) #for i in range(nnodes): #points.InsertPoint(i, nodes[i, :]) #elements = model.elements quads = model.quad_elements hexas = model.hexa_elements tets = model.tet_elements tris = model.tri_elements nquads = len(quads) ntris = len(tris) nhexas = len(hexas) ntets = len(tets) nshells = nquads + ntris nsolids = ntets + nhexas if nshells: is_surface = True self._create_tecplot_shells(nquads, quads, ntris, tris) self.nelements = nshells elif nsolids: #if 0: #tris, quads = model.skin_elements() #is_tris = bool(len(tris)) #is_quads = bool(len(quads)) #self._create_tecplot_shells(is_quads, quads, is_tris, tris) #else: is_surface = False if is_surface: if nhexas: free_faces = array(model.get_free_faces(), dtype='int32')# + 1 nfaces = len(free_faces) self.nelements = nfaces elements = free_faces grid.Allocate(nfaces, 1000) for face in free_faces: elem = vtkQuad() epoints = elem.GetPointIds() epoints.SetId(0, face[0]) epoints.SetId(1, face[1]) epoints.SetId(2, face[2]) epoints.SetId(3, face[3]) #elem.GetCellType() = 5 # vtkTriangle grid.InsertNextCell(elem.GetCellType(), elem.GetPointIds()) else: # is_volume grid.Allocate(nsolids, 1000) self.nelements = nsolids if ntets: for node_ids in tets: elem = vtkTetra() epoints = elem.GetPointIds() epoints.SetId(0, node_ids[0]) epoints.SetId(1, node_ids[1]) epoints.SetId(2, node_ids[2]) epoints.SetId(3, node_ids[3]) #elem.GetCellType() = 5 # vtkTriangle grid.InsertNextCell(elem.GetCellType(), elem.GetPointIds()) if nhexas: for node_ids in hexas: elem = vtkHexahedron() epoints = elem.GetPointIds() epoints.SetId(0, node_ids[0]) epoints.SetId(1, node_ids[1]) epoints.SetId(2, node_ids[2]) epoints.SetId(3, node_ids[3]) epoints.SetId(4, node_ids[4]) epoints.SetId(5, node_ids[5]) epoints.SetId(6, node_ids[6]) epoints.SetId(7, node_ids[7]) #elem.GetCellType() = 5 # vtkTriangle grid.InsertNextCell(elem.GetCellType(), elem.GetPointIds()) else: raise NotImplementedError() grid.SetPoints(points) grid.Modified() if hasattr(grid, 'Update'): grid.Update() return is_surface
def writeLegacyVTK(): # This is where the data is for testing purposes. print "Current working directory:", os.getcwd() if os.path.isdir("vtk") == False: os.makedirs("vtk") print "Cretated vtk output directory..." if os.path.isdir("files") == False: os.makedirs("files") print "Created files ouptut directory..." # Working with the task mesh. taskMeshReader = vtk.vtkXMLPolyDataReader() taskMeshReader.SetFileName(meshSet[0]) taskMeshReader.Update() taskMesh = taskMeshReader.GetOutput() # Get the range of branch labels. labelRange = [0, 0] taskMesh.GetCellData().GetScalars().GetRange(labelRange, 0) # Convert label range to a list of labels. labelRange = range(int(labelRange[0]), int(labelRange[1]) + 1) print "Labels found in task mesh:", labelRange # Store the number of rings for each label. numRingsPerLabel = {} # For every label in the range of labels we want to extract all cells/quads. for label in labelRange: # Use this filter to extract the cells for a given label value. branchSelector = vtk.vtkThreshold() branchSelector.SetInputData(taskMesh) branchSelector.ThresholdBetween(label,label); branchSelector.Update() taskMeshBranch = branchSelector.GetOutput() # New vtkPoints for storing reordered points. reorderedPoints = vtk.vtkPoints() # New vtkCellArray for storing reordeced cells. reorderedCellArray = vtk.vtkCellArray() numQuadRowsPerBranch = taskMeshBranch.GetNumberOfCells() / numQuadsPerRing; numRingsPerLabel[label] = numQuadRowsPerBranch ringIds = range(0, numQuadRowsPerBranch); # Working with rows in reverse order: UPSTREAM. ringIds.reverse() rowBase = 0 # Iterate over the rings in reverse order. for ringNum in ringIds: # Iterate over the cells in normal order. for cellNum in range(0, numQuadsPerRing): # Calculate the 'real' cell id and get the corresponding cell. cellId = ringNum * numQuadsPerRing + cellNum cell = taskMeshBranch.GetCell(cellId) # The ids to be written to the TXT file. pointIdList = [cell.GetNumberOfPoints()] # Write the appropriate points to TXT file. for pPos in range(0, cell.GetNumberOfPoints()): newPoint = False if ringNum == ringIds[0]: if cellNum == 0: newPoint = True elif pPos == 1 or pPos == 2: newPoint = True else: if cellNum == 0: if pPos == 0 or pPos == 1: newPoint = True else: if pPos == 1: newPoint = True if newPoint == True: # Inserting a new point... point = taskMeshBranch.GetPoint(cell.GetPointId(pPos)) # ... with a new id. newId = reorderedPoints.InsertNextPoint(point) pointIdList.append(newId) # To make it easier for remembering the number of points instered in a row. if cellNum == 0 and pPos == 0: rowBasePrev = newId else: # Perhaps this can be done in a nicer way. # Calculate the id of a previously inserted point. if ringNum == ringIds[0]: if cellNum == 1: if pPos == 0: pointIdList.append(1L) elif pPos == 3: pointIdList.append(2L) else: if pPos == 0: pointIdList.append(long(reorderedPoints.GetNumberOfPoints() - 2)) elif pPos == 3: pointIdList.append(long(reorderedPoints.GetNumberOfPoints() - 3)) elif ringNum == ringIds[1]: if cellNum == 0: if pPos == 2: pointIdList.append(1L) elif pPos == 3: pointIdList.append(0L) else: if pPos == 0: pointIdList.append(long(reorderedPoints.GetNumberOfPoints() - 1)) elif pPos == 2: pointIdList.append(long(cellNum * 2 + 2)) elif pPos == 3: if cellNum == 1: pointIdList.append(1L) else: pointIdList.append(long(cellNum * 2)) else: if cellNum == 0: if pPos == 2: pointIdList.append(long(rowBase + 1)) elif pPos == 3: pointIdList.append(long(rowBase)) else: if pPos == 0: pointIdList.append(long(reorderedPoints.GetNumberOfPoints() - 1)) elif pPos == 2: pointIdList.append(long(rowBase + cellNum + 1)) elif pPos == 3: pointIdList.append(long(rowBase + cellNum)) # print pointIdList, rowBase # Insert the ids into the cell array. newCell = vtk.vtkQuad() newCell.GetPointIds().Reset() for id in pointIdList[1:]: newCell.GetPointIds().InsertNextId(id) reorderedCellArray.InsertNextCell(newCell) rowBase = rowBasePrev # print '\n' print "Inserted", reorderedPoints.GetNumberOfPoints(), "task mesh points for label", label, "..." print "Inserted", reorderedCellArray.GetNumberOfCells(), "task mesh cells for label", label, "..." # Create new vtkPolyData object for the new reordered mesh. reorderedTaskMeshBranch = vtk.vtkPolyData() # Put the reordered points and cells into the reordered mesh. reorderedTaskMeshBranch.SetPoints(reorderedPoints) reorderedTaskMeshBranch.SetPolys(reorderedCellArray) # Write the VTK file. reorderedMeshWriter = vtk.vtkXMLPolyDataWriter() reorderedMeshWriter.SetInputData(reorderedTaskMeshBranch) reorderedMeshWriter.SetFileName(taskVTKFiles[label]) reorderedMeshWriter.Update() print "Rings per label:", numRingsPerLabel, "..." ringsPerLabelVals = numRingsPerLabel.values() # Check all rings per label values are the same. assert ringsPerLabelVals[1:] == ringsPerLabelVals[:-1], "All values of rings per label must be identical. Generated output is invalid ..." # Working with EC mesh. ecMeshReader = vtk.vtkXMLPolyDataReader() ecMeshReader.SetFileName(meshSet[1]) ecMeshReader.Update() # Original ECs mesh to work with. ecMesh = ecMeshReader.GetOutput() print "There are", ecMesh.GetNumberOfCells(), "ECs in total ..." # For every label in the range of labels we want to extract all ECs. for label in labelRange: # Keep track of how many branches we need to skip. numECsPerLabel = numQuadsPerRing * numRingsPerLabel[label] * numECsPerQuad ecCellOffset = label * numECsPerLabel print "ecCellOffset", ecCellOffset # Collect cell ids to select. selectionIds = vtk.vtkIdTypeArray() for sId in range(0, numECsPerLabel): selectionIds.InsertNextValue(ecCellOffset + sId) # Create selecion node. selectionNode = vtk.vtkSelectionNode() selectionNode.SetFieldType(selectionNode.CELL) selectionNode.SetContentType(selectionNode.INDICES) selectionNode.SetSelectionList(selectionIds) # Create selection. selection = vtk.vtkSelection() selection.AddNode(selectionNode) # Use vtkSelection filter. selectionExtractor = vtk.vtkExtractSelection() selectionExtractor.SetInputData(0, ecMesh) selectionExtractor.SetInputData(1, selection) selectionExtractor.Update() extractedECs = selectionExtractor.GetOutput() # Ring ids list for traversal. ringIds = range(0, numRingsPerLabel[label]) ringIds.reverse() # Number of ECs rows is the number of ECs per quad. rowIds = range(0, numECsPerCol) rowIds.reverse() # The ECs are organised in rings of blocks of cells. # New vtkCellArray for storing reordeced cells. reorderedCellArray = vtk.vtkCellArray() # Iterate over the rings in reverse order. for ringNum in ringIds: # Iterate over the 'imaginary' quads of cells in normal order. for quadNum in range(0, numQuadsPerRing): # Iterate over the rows of cells in reverse order. # Calculate the 'real' id for the 'imaginary' quad. quadId = ringNum * numQuadsPerRing + quadNum # Iterate over rows of cells in reverse order. for rowNum in rowIds: # Iterate over the rows of cells in normal order. for ecNum in range(0, numECsPerRow): # Calculate the 'real' ec cell id and get the corresponding cell. ecId = quadId * numECsPerQuad + rowNum * numECsPerRow + ecNum ecCell = extractedECs.GetCell(ecId) reorderedCellArray.InsertNextCell(ecCell) # Create new vtkPolyData object for the new reordered mesh. reorderedECMeshBranch = vtk.vtkPolyData() # Insert our new points. reorderedECMeshBranch.SetPoints(extractedECs.GetPoints()) # Set the reordered cells to the reordered ECs mesh. reorderedECMeshBranch.SetPolys(reorderedCellArray) # New vtkPoints for storing reordered points. reorderedPoints = vtk.vtkPoints() # New vtkCellArray for storing reordeced cells. reorderedCellArray = vtk.vtkCellArray() rowBase = 0 # Iterate over quads in normal order because they have been reordered. for quadNum in range(0, numRingsPerLabel[label] * numQuadsPerRing): # Iterate over rows in normal order because they have been reordered. for rowNum in range(0, numECsPerCol): # Iterate over the ECs in the row in normal order. for ecNum in range(0, numECsPerRow): # Calculate the 'real' ec cell id and get the corresponding cell. ecId = quadNum * numECsPerQuad + rowNum * numECsPerRow + ecNum ecCell = reorderedECMeshBranch.GetCell(ecId) # The ids to be written to the TXT file. pointIdList = [ecCell.GetNumberOfPoints()] # Write the appropriate points to the TXT file. for pPos in range(0, ecCell.GetNumberOfPoints()): newPoint = False if rowNum == 0: if ecNum == 0: newPoint = True elif pPos == 1 or pPos == 2: newPoint = True else: if ecNum == 0: if pPos == 0 or pPos == 1: newPoint = True else: if pPos == 1: newPoint = True if newPoint == True: # Inserting a new point... point = reorderedECMeshBranch.GetPoint(ecCell.GetPointId(pPos)) # ... with a new id. newId = reorderedPoints.InsertNextPoint(point) pointIdList.append(newId) if ecNum == 0 and pPos == 0: rowBasePrev = newId else: # Perhaps this can be done in a nicer way. # Calculate the ide of a previously inserted point. if rowNum == 0: if ecNum == 1: if pPos == 0: pointIdList.append(long(reorderedPoints.GetNumberOfPoints() - 3)) elif pPos == 3: pointIdList.append(long(reorderedPoints.GetNumberOfPoints() - 4)) else: if pPos == 0: pointIdList.append(long(reorderedPoints.GetNumberOfPoints() - 2)) elif pPos == 3: pointIdList.append(long(reorderedPoints.GetNumberOfPoints() - 3)) elif rowNum == 1: if ecNum == 0: if pPos == 2: pointIdList.append(long(rowBase + 1)) elif pPos == 3: pointIdList.append(long(rowBase)) else: if pPos == 0: pointIdList.append(long(reorderedPoints.GetNumberOfPoints() - 1)) elif pPos == 2: pointIdList.append(long(rowBase + ecNum * 2 + 2)) elif pPos == 3: if ecNum == 1: pointIdList.append(long(rowBase + 1)) else: pointIdList.append(long(rowBase + ecNum * 2)) else: if ecNum == 0: if pPos == 2: pointIdList.append(long(rowBase + 1)) elif pPos == 3: pointIdList.append(long(rowBase)) else: if pPos == 0: pointIdList.append(long(reorderedPoints.GetNumberOfPoints() - 1)) elif pPos == 2: pointIdList.append(long(rowBase + ecNum + 1)) elif pPos == 3: pointIdList.append(long(rowBase + ecNum)) # print pointIdList, rowBase # Insert the ids into the cell array. newCell = vtk.vtkQuad() newCell.GetPointIds().Reset() for id in pointIdList[1:]: newCell.GetPointIds().InsertNextId(id) reorderedCellArray.InsertNextCell(newCell) rowBase = rowBasePrev # print '\n' print "There are", reorderedPoints.GetNumberOfPoints(), "ECs points for label", label, "..." print "There are", reorderedCellArray.GetNumberOfCells(), "ECs cells for label", label, "..." # Create new vtkPolyData object for the new reordered mesh. reorderedECs = vtk.vtkPolyData() # Put the reordered points and cells into the mesh. reorderedECs.SetPoints(reorderedPoints) reorderedECs.SetPolys(reorderedCellArray) # Write the VTK EC mesh file. reorderedMeshWriter = vtk.vtkXMLPolyDataWriter() reorderedMeshWriter.SetInputData(reorderedECs) reorderedMeshWriter.SetFileName(ecVTKFiles[label]) reorderedMeshWriter.Update() # Use VTK centroid filter to get the centroids in the right order # from the reorderedECMeshBranch. centroidFilter = vtk.vtkCellCenters() centroidFilter.SetInputData(reorderedECs) centroidFilter.Update() # Create a vertex cell for each point. pointsToVerticesFilter = vtk.vtkVertexGlyphFilter() pointsToVerticesFilter.SetInputData(centroidFilter.GetOutput()) pointsToVerticesFilter.Update() reorderedCentroidBranch = pointsToVerticesFilter.GetOutput() # Write the VTK EC centrouid file. centroidWriter = vtk.vtkXMLPolyDataWriter() centroidWriter.SetInputData(reorderedCentroidBranch) centroidWriter.SetFileName(ecCentroidVTKFiles[label]) centroidWriter.Update() # Write the centroids to the TXT points and cells files. for cId in range(0, reorderedCentroidBranch.GetNumberOfCells()): centCell = reorderedCentroidBranch.GetCell(cId) centIds = [centCell.GetNumberOfPoints()] # Write centroid ids. ptId = centCell.GetPointId(0) centIds.append(ptId) # Write centroid points. point = reorderedCentroidBranch.GetPoint(ptId) # Working with SMC mesh. # Working with SMC mesh. # Working with SMC mesh. smcMeshReader = vtk.vtkXMLPolyDataReader() smcMeshReader.SetFileName(meshSet[2]) smcMeshReader.Update() # Original SMCs mesh to work with. smcMesh = smcMeshReader.GetOutput() print "There are", smcMesh.GetNumberOfCells(), "SMCs in total ..." # For every label in the range of labels we want to extract all SMCs. for label in labelRange: # Keep track of how many branches we need to skip. numSMCsPerLabel = numQuadsPerRing * numRingsPerLabel[label] * numSMCsPerQuad smcCellOffset = label * numSMCsPerLabel print "smcCellOffset", smcCellOffset # Collect cell ids to select. selectionIds = vtk.vtkIdTypeArray() for sId in range(0, numSMCsPerLabel): selectionIds.InsertNextValue(smcCellOffset + sId) # Create selecion node. selectionNode = vtk.vtkSelectionNode() selectionNode.SetFieldType(selectionNode.CELL) selectionNode.SetContentType(selectionNode.INDICES) selectionNode.SetSelectionList(selectionIds) # Create selection. selection = vtk.vtkSelection() selection.AddNode(selectionNode) # Use vtkSelection filter. selectionExtractor = vtk.vtkExtractSelection() selectionExtractor.SetInputData(0, smcMesh) selectionExtractor.SetInputData(1, selection) selectionExtractor.Update() extractedSMCs = selectionExtractor.GetOutput() # Ring ids list for traversal. ringIds = range(0, numRingsPerLabel[label]) ringIds.reverse() # Number of SMCs rows is the number of ECs per quad times 13. rowIds = range(0, numSMCsPerCol) rowIds.reverse() # The SMCs are organised in rings of blocks of cells. # New vtkCellArray for storing reordeced cells. reorderedCellArray = vtk.vtkCellArray() # Iterate over the rings in reverse order. for ringNum in ringIds: # Iterate over the 'imaginary' quads of cells in normal order. for quadNum in range(0, numQuadsPerRing): # Iterate over the rows of cells in reverse order. # Calculate the 'real' id for the 'imaginary' quad. quadId = ringNum * numQuadsPerRing + quadNum # Iterate over rows of cells in reverse order. for rowNum in rowIds: # Iterate over the rows of cells in normal order. for smcNum in range(0, numSMCsPerRow): # Calculate the 'real' smc cell id and get the corresponding cell. smcId = quadId * numSMCsPerQuad + rowNum * numSMCsPerRow + smcNum smcCell = extractedSMCs.GetCell(smcId) reorderedCellArray.InsertNextCell(smcCell) # Create new vtkPolyData object for the new reordered mesh. reorderedSMCMeshBranch = vtk.vtkPolyData() # Insert our new points. reorderedSMCMeshBranch.SetPoints(extractedSMCs.GetPoints()) # Set the reordered cells to the reordered SMCs mesh. reorderedSMCMeshBranch.SetPolys(reorderedCellArray) # New vtkPoints for storing reordered points. reorderedPoints = vtk.vtkPoints() # New vtkCellArray for storing reordeced cells. reorderedCellArray = vtk.vtkCellArray() rowBase = 0 # Iterate over quads in normal order because they have been reordered. for quadNum in range(0, numRingsPerLabel[label] * numQuadsPerRing): # Iterate over rows in normal order because they have been reordered. for rowNum in range(0, numSMCsPerCol): # Iterate over the SMCs in the row in normal order. for smcNum in range(0, numSMCsPerRow): # Calculate the 'real' smc cell id and get the corresponding cell. smcId = quadNum * numSMCsPerQuad + rowNum * numSMCsPerRow + smcNum smcCell = reorderedSMCMeshBranch.GetCell(smcId) # The ids to be written to the TXT file. pointIdList = [smcCell.GetNumberOfPoints()] # Write the appropriate points to the TXT file. for pPos in range(0, smcCell.GetNumberOfPoints()): newPoint = False if rowNum == 0: if smcNum == 0: newPoint = True elif pPos == 1 or pPos == 2: newPoint = True else: if smcNum == 0: if pPos == 0 or pPos == 1: newPoint = True else: if pPos == 1: newPoint = True if newPoint == True: # Inserting a new point... point = reorderedSMCMeshBranch.GetPoint(smcCell.GetPointId(pPos)) # with a new id. newId = reorderedPoints.InsertNextPoint(point) pointIdList.append(newId) if smcNum == 0 and pPos == 0: rowBasePrev = newId else: # Perhaps this can be done in a nicer way. # Calculate the ide of a previously inserted point. if rowNum == 0: if smcNum == 1: if pPos == 0: pointIdList.append(long(reorderedPoints.GetNumberOfPoints() - 3)) elif pPos == 3: pointIdList.append(long(reorderedPoints.GetNumberOfPoints() - 4)) else: if pPos == 0: pointIdList.append(long(reorderedPoints.GetNumberOfPoints() - 2)) elif pPos == 3: pointIdList.append(long(reorderedPoints.GetNumberOfPoints() - 3)) elif rowNum == 1: if smcNum == 0: if pPos == 2: pointIdList.append(long(rowBase + 1)) elif pPos == 3: pointIdList.append(long(rowBase)) else: if pPos == 0: pointIdList.append(long(reorderedPoints.GetNumberOfPoints() - 1)) elif pPos == 2: pointIdList.append(long(rowBase + smcNum * 2 + 2)) elif pPos == 3: if smcNum == 1: pointIdList.append(long(rowBase + 1)) else: pointIdList.append(long(rowBase + smcNum * 2)) else: if smcNum == 0: if pPos == 2: pointIdList.append(long(rowBase + 1)) elif pPos == 3: pointIdList.append(long(rowBase)) else: if pPos == 0: pointIdList.append(long(reorderedPoints.GetNumberOfPoints() - 1)) elif pPos == 2: pointIdList.append(long(rowBase + smcNum + 1)) elif pPos == 3: pointIdList.append(long(rowBase + smcNum)) # print pointIdList, rowBase # Insert the ids into the cell array. newCell = vtk.vtkQuad() newCell.GetPointIds().Reset() for id in pointIdList[1:]: newCell.GetPointIds().InsertNextId(id) reorderedCellArray.InsertNextCell(newCell) rowBase = rowBasePrev # print '\n' print "There are", reorderedPoints.GetNumberOfPoints(), "SMCs points for label", label, "..." print "There are", reorderedCellArray.GetNumberOfCells(), "SMCs cells for label", label, "..." # Create new vtkPolyData object for the new reordered mesh. reorderedSMCs = vtk.vtkPolyData() # Put the reordered points and cells in to the mesh. reorderedSMCs.SetPoints(reorderedPoints) reorderedSMCs.SetPolys(reorderedCellArray) # Write the VTK SMC mesh file. reorderedMeshWriter = vtk.vtkXMLPolyDataWriter() reorderedMeshWriter.SetInputData(reorderedSMCs) reorderedMeshWriter.SetFileName(smcVTKFiles[label]) reorderedMeshWriter.Update() print "All done ..." print "... Except the last configuration_info.txt file ..." configFile = open("files/configuration_info.txt", 'w') configFile.write("Processors information\n") configFile.write("Total number of points per branch (vtk points) = %d\t\tm = %d n = %d\n" \ % ((numQuadsPerRing + 1) * (numRingsPerLabel[0] + 1), (numQuadsPerRing + 1), (numRingsPerLabel[0] + 1))) configFile.write("Total number of cells per branch (vtk cells) = %d\t\tm = %d n = %d\n" \ % (numQuadsPerRing * numRingsPerLabel[0], numQuadsPerRing, numRingsPerLabel[0])) configFile.write("Total number of SMC mesh points per processor mesh (vtk points) = %d\t\tm = %d n = %d\n" \ % ((numSMCsPerCol + 1) * (numSMCsPerRow + 1), (numSMCsPerCol + 1), (numSMCsPerRow + 1))) configFile.write("Total number of SMC mesh cells per processor mesh (vtk cells) = %d\t\tm = %d n = %d\n" \ % (numSMCsPerCol * numSMCsPerRow, numSMCsPerCol, numSMCsPerRow)) configFile.write("Total number of EC mesh points per processor mesh (vtk points) = %d\t\tm = %d n = %d\n" \ % ((numECsPerCol + 1) * (numECsPerRow + 1), (numECsPerCol + 1), (numECsPerRow + 1))) configFile.write("Total number of EC mesh cells per processor mesh (vtk cells) = %d\t\tm = %d n = %d\n" \ % (numECsPerCol *numECsPerRow, numECsPerCol, numECsPerRow)) configFile.write("Total number of EC mesh centeroid points per processor mesh (vtk points) = %d\t\tm = %d n = %d\n" \ % (numECsPerCol *numECsPerRow, numECsPerCol, numECsPerRow)) configFile.write("Total number of EC mesh centeroid cells per processor mesh (vtk cells) = %d\t\tm = %d n = %d\n" \ % (numECsPerCol *numECsPerRow, numECsPerCol, numECsPerRow)) configFile.close() print "Now it is all done for real ..."
def _make_avus_geometry(self, model, quads_only=False): nodes = model.nodes #nnodes = self.nnodes grid = self.parent.grid mmax = amax(nodes, axis=0) mmin = amin(nodes, axis=0) dim_max = (mmax - mmin).max() self.parent.create_global_axes(dim_max) points = numpy_to_vtk_points(nodes) #elements = model.elements quads = model.quad_elements hexas = model.hexa_elements tets = model.tet_elements tris = model.tri_elements nquads = len(quads) ntris = len(tris) nhexas = len(hexas) ntets = len(tets) is_shells = nquads + ntris is_solids = ntets + nhexas if is_shells: is_surface = True if nquads: elements = quads for face in quads: elem = vtkQuad() epoints = elem.GetPointIds() epoints.SetId(0, face[0]) epoints.SetId(1, face[1]) epoints.SetId(2, face[2]) epoints.SetId(3, face[3]) #elem.GetCellType() = 5 # vtkTriangle grid.InsertNextCell(elem.GetCellType(), elem.GetPointIds()) if ntris: elements = tris for face in tris: elem = vtkTriangle() epoints = elem.GetPointIds() epoints.SetId(0, face[0]) epoints.SetId(1, face[1]) epoints.SetId(2, face[2]) #elem.GetCellType() = 5 # vtkTriangle grid.InsertNextCell(5, elem.GetPointIds()) elif is_solids: if ntets: elements = tets is_surface = False self.nelements = model.nelements grid.Allocate(self.nelements, 1000) nelements = elements.shape[0] for node_ids in elements: elem = vtkTetra() epoints = elem.GetPointIds() epoints.SetId(0, node_ids[0]) epoints.SetId(1, node_ids[1]) epoints.SetId(2, node_ids[2]) epoints.SetId(3, node_ids[3]) #elem.GetCellType() = 5 # vtkTriangle grid.InsertNextCell(elem.GetCellType(), elem.GetPointIds()) if nhexas: elements = hexas is_surface = True # is_surface = False is_volume = not is_surface if is_surface: self.nelements = model.nelements free_faces = array(model.get_free_faces(), dtype='int32')# + 1 nfaces = len(free_faces) elements = free_faces grid.Allocate(nfaces, 1000) for face in free_faces: elem = vtkQuad() epoints = elem.GetPointIds() epoints.SetId(0, face[0]) epoints.SetId(1, face[1]) epoints.SetId(2, face[2]) epoints.SetId(3, face[3]) #elem.GetCellType() = 5 # vtkTriangle grid.InsertNextCell(elem.GetCellType(), elem.GetPointIds()) elif is_volume: self.nelements = model.nelements grid.Allocate(self.nelements, 1000) nelements = elements.shape[0] for eid in range(nelements): elem = vtkHexahedron() node_ids = elements[eid, :] epoints = elem.GetPointIds() epoints.SetId(0, node_ids[0]) epoints.SetId(1, node_ids[1]) epoints.SetId(2, node_ids[2]) epoints.SetId(3, node_ids[3]) epoints.SetId(4, node_ids[4]) epoints.SetId(5, node_ids[5]) epoints.SetId(6, node_ids[6]) epoints.SetId(7, node_ids[7]) #elem.GetCellType() = 5 # vtkTriangle grid.InsertNextCell(elem.GetCellType(), elem.GetPointIds()) else: raise NotImplementedError() grid.SetPoints(points) grid.Modified() if hasattr(grid, 'Update'): grid.Update() return is_surface
def rhombicuboctahedron(): import vtk # First, you need to store the vertex locations. import numpy as np fu = 1 # full unit hu = .5 # half unit d = np.sqrt((fu ** 2) / 2) # diag hh = hu + d # half height # left view faces us import utool as ut import six import itertools counter = ut.partial(six.next, itertools.count(0)) vertex_locations = vtk.vtkPoints() vertex_locations.SetNumberOfPoints(24) p1, p2, p3 = np.array([ (-hu, -hu, hh), ( hu, -hu, hh), ( hu, hu, hh), (-hu, hu, hh), ]).T plist = [p1, p2, p3] # three of the six main faces #perms = list(itertools.permutations((0, 1, 2), 3)) perms = [(0, 1, 2), (0, 2, 1), (2, 0, 1)] vertex_array = [] # VERTEXES # left, up, back vplist = ['L', 'U', 'B', 'R', 'D', 'F'] vpdict = {} print('perms = %r' % (perms,)) for x in range(3): vp = vplist[x] p = np.vstack(ut.take(plist, perms[x])).T counts = [counter() for z in range(4)] vpdict[vp] = counts vertex_array.extend(p.tolist()) vertex_locations.SetPoint(counts[0], p[0]) vertex_locations.SetPoint(counts[1], p[1]) vertex_locations.SetPoint(counts[2], p[2]) vertex_locations.SetPoint(counts[3], p[3]) # three more of the six main faces perms = [(0, 1, 2), (0, 2, 1), (2, 0, 1)] plist[-1] = -plist[-1] # right, down, front print('perms = %r' % (perms,)) for x in range(3): p = np.vstack(ut.take(plist, perms[x])).T counts = [counter() for z in range(4)] vp = vplist[x + 3] vpdict[vp] = counts vertex_array.extend(p.tolist()) vertex_locations.SetPoint(counts[0], p[0]) vertex_locations.SetPoint(counts[1], p[1]) vertex_locations.SetPoint(counts[2], p[2]) vertex_locations.SetPoint(counts[3], p[3]) pd = vtk.vtkPolyData() pd.SetPoints(vertex_locations) polygon_faces = vtk.vtkCellArray() face_dict = { 'L': [vpdict['L'][0], vpdict['L'][1], vpdict['L'][2], vpdict['L'][3]], 'D': [vpdict['D'][0], vpdict['D'][1], vpdict['D'][2], vpdict['D'][3]], 'U': [vpdict['U'][0], vpdict['U'][1], vpdict['U'][2], vpdict['U'][3]], 'F': [vpdict['F'][0], vpdict['F'][1], vpdict['F'][2], vpdict['F'][3]], 'R': [vpdict['R'][0], vpdict['R'][1], vpdict['R'][2], vpdict['R'][3]], 'B': [vpdict['B'][0], vpdict['B'][1], vpdict['B'][2], vpdict['B'][3]], 'FL': [ vpdict['L'][0], vpdict['L'][3], vpdict['F'][2], vpdict['F'][3], ], 'BL': [ vpdict['L'][1], vpdict['L'][2], vpdict['B'][2], vpdict['B'][3], ], 'UL': [ vpdict['L'][2], vpdict['L'][3], vpdict['U'][3], vpdict['U'][2], ], 'DL': [ vpdict['L'][0], vpdict['L'][1], vpdict['D'][2], vpdict['D'][3], ], 'UFL': [ vpdict['L'][3], vpdict['F'][2], vpdict['U'][3], ], 'DFL': [ vpdict['L'][0], vpdict['F'][3], vpdict['D'][3], ], 'UBL': [ vpdict['L'][2], vpdict['B'][2], vpdict['U'][2], ], 'DBL': [ vpdict['L'][1], vpdict['B'][3], vpdict['D'][2], ], 'UFR': [ vpdict['R'][3], vpdict['F'][1], vpdict['U'][0], ], 'DFR': [ vpdict['R'][0], vpdict['F'][0], vpdict['D'][0], ], 'UBR': [ vpdict['R'][2], vpdict['B'][1], vpdict['U'][1], ], 'DBR': [ vpdict['R'][1], vpdict['B'][0], vpdict['D'][1], ], 'FR': [ vpdict['R'][3], vpdict['R'][0], vpdict['F'][0], vpdict['F'][1], ], 'BR': [ vpdict['R'][2], vpdict['R'][1], vpdict['B'][0], vpdict['B'][1], ], 'UR': [ vpdict['R'][3], vpdict['R'][2], vpdict['U'][1], vpdict['U'][0], ], 'DR': [ vpdict['R'][1], vpdict['R'][0], vpdict['D'][0], vpdict['D'][1], ], 'DF': [ vpdict['F'][0], vpdict['F'][3], vpdict['D'][3], vpdict['D'][0], ], 'DB': [ vpdict['B'][3], vpdict['B'][0], vpdict['D'][1], vpdict['D'][2], ], 'UF': [ vpdict['F'][1], vpdict['F'][2], vpdict['U'][3], vpdict['U'][0], ], 'UB': [ vpdict['B'][2], vpdict['B'][1], vpdict['U'][1], vpdict['U'][2], ], } for key, vert_ids in face_dict.items(): #if key != 'L': # continue if len(vert_ids) == 4: q = vtk.vtkQuad() else: q = vtk.vtkTriangle() for count, idx in enumerate(vert_ids): q.GetPointIds().SetId(count, idx) polygon_faces.InsertNextCell(q) # Next you create a vtkPolyData to store your face and vertex information #that # represents your polyhedron. pd = vtk.vtkPolyData() pd.SetPoints(vertex_locations) pd.SetPolys(polygon_faces) face_stream = vtk.vtkIdList() face_stream.InsertNextId(polygon_faces.GetNumberOfCells()) vertex_list = vtk.vtkIdList() polygon_faces.InitTraversal() while polygon_faces.GetNextCell(vertex_list) == 1: face_stream.InsertNextId(vertex_list.GetNumberOfIds()) for j in range(vertex_list.GetNumberOfIds()): face_stream.InsertNextId(vertex_list.GetId(j)) ug = vtk.vtkUnstructuredGrid() ug.SetPoints(vertex_locations) ug.InsertNextCell(vtk.VTK_POLYHEDRON, face_stream) #writer = vtk.vtkUnstructuredGridWriter() #writer.SetFileName("rhombicuboctahedron.vtk") ##writer.SetInputData(ug) #writer.SetInput(ug) #writer.Write() mapper = vtk.vtkDataSetMapper() mapper.SetInput(ug) actor = vtk.vtkActor() actor.SetMapper(mapper) if 1: # Read the image data from a file import utool as ut textureCoords = vtk.vtkFloatArray() textureCoords.SetNumberOfComponents(3) #coords = ut.take(vertex_array, face_dict['L']) #for coord in coords: # textureCoords.InsertNextTuple(tuple(coord)) textureCoords.InsertNextTuple((0, 0, 0)) textureCoords.InsertNextTuple((1, 0, 0)) textureCoords.InsertNextTuple((1, 1, 0)) textureCoords.InsertNextTuple((0, 1, 0)) # Create texture object fpath = ut.grab_test_imgpath('zebra.png') reader = vtk.vtkPNGReader() reader.SetFileName(fpath) texture = vtk.vtkTexture() texture.SetInput(reader.GetOutput()) texture.RepeatOff() texture.InterpolateOff() ptdat = pd.GetPointData() ptdat.SetTCoords(textureCoords) actor.SetTexture(texture) ren = vtk.vtkRenderer() ren.AddActor(actor) renw = vtk.vtkRenderWindow() renw.AddRenderer(ren) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renw) ren.ResetCamera() renw.Render() iren.Start()
def main(): grid = vtk.vtkUnstructuredGrid() grid_mapper = vtk.vtkDataSetMapper() if vtk.VTK_VERSION >= 6: grid_mapper.SetInputData(grid) else: grid_mapper.SetInput(grid) #if vtk.VTK_VERSION[0] <= 5: # grid_mapper.SetInputConnection(grid.GetProducerPort()) #else: # grid_mapper.SetInputData(grid) nodes = np.array([ [0., 0., 0.], [1., 0., 0.], [1., 1., 0.], [0., 2., 1.], ], dtype='float32') points = vtk.vtkPoints() points.SetNumberOfPoints(4) points_array = numpy_to_vtk( num_array=nodes, deep=True, array_type=vtk.VTK_FLOAT, ) nelements = 1 grid.Allocate(nelements, 1000) grid.SetPoints(points) elem = vtk.vtkQuad() pts = elem.GetPointIds() pts.SetId(0, 0) pts.SetId(1, 1) pts.SetId(2, 2) pts.SetId(3, 3) grid.InsertNextCell(elem.GetCellType(), pts) grid.Modified() forces = np.array([ [0., 0.1, 0.], [0., 0., 0.], [0., 0., 0.], [0., 0., .3], ], dtype='float32') rend = vtk.vtkRenderer() if 1: maskPts = vtk.vtkMaskPoints() if vtk.VTK_VERSION <= 5: maskPts.SetInputConnection(grid.GetProducerPort()) else: maskPts.SetInputData(grid) arrow = vtk.vtkArrowSource() arrow.SetTipResolution(16) arrow.SetTipLength(0.3) arrow.SetTipRadius(0.1) glyph = vtk.vtkGlyph3D() glyph.SetSourceConnection(arrow.GetOutputPort()) glyph.SetInputConnection(maskPts.GetOutputPort()) glyph.SetVectorModeToUseNormal() glyph.SetScaleFactor(1) glyph.SetColorModeToColorByVector() glyph.SetScaleModeToScaleByVector() glyph.OrientOn() glyph.Update() glyph_mapper = vtk.vtkPolyDataMapper() glyph_mapper.SetInputConnection(glyph.GetOutputPort()) glyph_mapper.SetScalarModeToUsePointFieldData() glyph_mapper.SetColorModeToMapScalars() glyph_mapper.ScalarVisibilityOn() glyph_mapper.SelectColorArray('Elevation') # Colour by scalars. #glyph_mapper.SetScalarRange(scalarRangeElevation) glyph_actor = vtk.vtkActor() glyph_actor.SetMapper(glyph_mapper) glyph_actor.RotateX(-45) glyph_actor.RotateZ(45) rend.AddViewProp(glyph_actor) #rend.AddActor(glyph_actor) geom_actor = vtk.vtkActor() geom_actor.SetMapper(grid_mapper) # ------------------------------------------------------------ # Create the RenderWindow, Renderer and Interactor # ------------------------------------------------------------ renWin = vtk.vtkRenderWindow() iren = vtk.vtkRenderWindowInteractor() renWin.AddRenderer(rend) iren.SetRenderWindow(renWin) # add actors #rend.AddViewProp(geom_actor) #rend.AddViewProp(edgeActor) rend.AddActor(geom_actor) #rend.AddViewProp(glyph_actor) #rend.AddActor2D(scalarBar) rend.SetBackground(0.7, 0.8, 1.0) renWin.SetSize(800, 800) renWin.Render() iren.Start()
def load_panair_geometry(self, panairFileName, dirname, plot=True): self.nidMap = {} #key = self.caseKeys[self.iCase] #case = self.resultCases[key] skipReading = self.removeOldGeometry(panairFileName) if skipReading: return model = PanairGrid(log=self.log, debug=self.debug) self.modelType = model.modelType model.read_panair(panairFileName) nodes, elements, regions = model.getPointsElementsRegions() #for nid,node in enumerate(nodes): #print "node[%s] = %s" %(nid,str(node)) self.nNodes = len(nodes) self.nElements = len(elements) #print("nNodes = ",self.nNodes) #print("nElements = ", self.nElements) self.grid.Allocate(self.nElements, 1000) #self.gridResult.SetNumberOfComponents(self.nElements) self.grid2.Allocate(1, 1000) points = vtk.vtkPoints() points.SetNumberOfPoints(self.nNodes) #self.gridResult.Allocate(self.nNodes, 1000) #vectorReselt.SetNumberOfComponents(3) #elem.SetNumberOfPoints(nNodes) if 0: fraction = 1. / nNodes # so you can color the nodes by ID for nid, node in sorted(iteritems(nodes)): points.InsertPoint(nid - 1, *point) self.gridResult.InsertNextValue(nid * fraction) #print str(element) #elem = vtk.vtkVertex() #elem.GetPointIds().SetId(0, i) #self.aQuadGrid.InsertNextCell(elem.GetCellType(), elem.GetPointIds()) #vectorResult.InsertTuple3(0, 0.0, 0.0, 1.0) assert len(nodes) > 0 mmax = amax(nodes, axis=0) mmin = amin(nodes, axis=0) dim_max = (mmax - mmin).max() self.update_axes_length(dim_max) for nid, node in enumerate(nodes): points.InsertPoint(nid, *node) assert len(elements) > 0 for eid, element in enumerate(elements): (p1, p2, p3, p4) = element #print "element = ",element elem = vtkQuad() elem.GetPointIds().SetId(0, p1) elem.GetPointIds().SetId(1, p2) elem.GetPointIds().SetId(2, p3) elem.GetPointIds().SetId(3, p4) self.grid.InsertNextCell(elem.GetCellType(), elem.GetPointIds()) #print("eid = ", eid) self.grid.SetPoints(points) #self.grid2.SetPoints(points2) #self.grid.GetPointData().SetScalars(self.gridResult) #print dir(self.grid) #.SetNumberOfComponents(0) #self.grid.GetCellData().SetNumberOfTuples(1); #self.grid.GetCellData().SetScalars(self.gridResult) self.grid.Modified() self.grid2.Modified() if hasattr(self.grid, 'Update'): self.grid.Update() self.grid2.Update() print("updated grid") #return # loadCart3dResults - regions/loads self.TurnTextOn() self.scalarBar.VisibilityOn() self.scalarBar.Modified() self.iSubcaseNameMap = {1: ['Panair', '']} cases = {} ID = 1 #print "nElements = ",nElements loads = [] cases = self.fillPanairGeometryCase(cases, ID, nodes, elements, regions, loads) self._finish_results_io(cases)
def readAbaqusMesh(mesh_filename, elem_types="all", verbose=True): if (verbose): print "*** readAbaqusMesh ***" points = vtk.vtkPoints() cell_array = vtk.vtkCellArray() mesh_file = open(mesh_filename, "r") context = "" for line in mesh_file: if (line[-1:] == "\n"): line = line[:-1] #if (verbose): print "line =", line if line.startswith("**"): continue if (context == "reading nodes"): if line.startswith("*"): context = "" else: splitted_line = line.split(",") points.InsertNextPoint( [float(coord) for coord in splitted_line[1:4]]) if (context == "reading elems"): if line.startswith("*"): context = "" else: splitted_line = line.split(",") assert (len(splitted_line) == 1 + cell_nb_points ), "Wrong number of elements in line. Aborting." for num_point in range(cell_nb_points): cell.GetPointIds().SetId( num_point, int(splitted_line[1 + num_point]) - 1) cell_array.InsertNextCell(cell) if line.startswith("*NODE"): context = "reading nodes" if line.startswith("*ELEMENT"): if ("TYPE=F3D4" in line) and (("quad" in elem_types) or ("all" in elem_types)): context = "reading elems" cell_vtk_type = vtk.VTK_QUAD cell_nb_points = 4 cell = vtk.vtkQuad() elif ("TYPE=C3D4" in line) and (("tet" in elem_types) or ("all" in elem_types)): context = "reading elems" cell_vtk_type = vtk.VTK_TETRA cell_nb_points = 4 cell = vtk.vtkTetra() elif ("TYPE=C3D8" in line) and (("hex" in elem_types) or ("all" in elem_types)): context = "reading elems" cell_vtk_type = vtk.VTK_HEXAHEDRON cell_nb_points = 8 cell = vtk.vtkHexahedron() else: print "Warning: element type not taken into account." mesh_file.close() if (verbose): print "Creating UGrid..." ugrid = vtk.vtkUnstructuredGrid() ugrid.SetPoints(points) ugrid.SetCells(cell_vtk_type, cell_array) if (verbose): print "nb_cells = " + str(ugrid.GetNumberOfCells()) return ugrid
def setup_renderers(renwin, fg_ren, bg_ren): """Utility method to configure foreground and background renderer and insert them into different layers of the renderenwinindow. Use this if you want an incredibly cool gradient background! """ # bit of code thanks to # http://www.bioengineering-research.com/vtk/BackgroundGradient.tcl # had to change approach though to using background renderer, # else transparent objects don't appear, and adding flat # shaded objects breaks the background gradient. # ================================================================= qpts = vtk.vtkPoints() qpts.SetNumberOfPoints(4) qpts.InsertPoint(0, 0, 0, 0) qpts.InsertPoint(1, 1, 0, 0) qpts.InsertPoint(2, 1, 1, 0) qpts.InsertPoint(3, 0, 1, 0) quad = vtk.vtkQuad() quad.GetPointIds().SetId(0,0) quad.GetPointIds().SetId(1,1) quad.GetPointIds().SetId(2,2) quad.GetPointIds().SetId(3,3) uc = vtk.vtkUnsignedCharArray() uc.SetNumberOfComponents(4) uc.SetNumberOfTuples(4) uc.SetTuple4(0, 128, 128, 128, 255) # bottom left RGBA uc.SetTuple4(1, 128, 128, 128, 255) # bottom right RGBA uc.SetTuple4(2, 255, 255, 255, 255) # top right RGBA uc.SetTuple4(3, 255, 255, 255, 255) # tob left RGBA dta = vtk.vtkPolyData() dta.Allocate(1,1) dta.InsertNextCell(quad.GetCellType(), quad.GetPointIds()) dta.SetPoints(qpts) dta.GetPointData().SetScalars(uc) coord = vtk.vtkCoordinate() coord.SetCoordinateSystemToNormalizedDisplay() mapper2d = vtk.vtkPolyDataMapper2D() mapper2d.SetInput(dta) mapper2d.SetTransformCoordinate(coord) actor2d = vtk.vtkActor2D() actor2d.SetMapper(mapper2d) actor2d.GetProperty().SetDisplayLocationToBackground() bg_ren.AddActor(actor2d) bg_ren.SetLayer(0) # seems to be background bg_ren.SetInteractive(0) fg_ren.SetLayer(1) # and foreground renwin.SetNumberOfLayers(2) renwin.AddRenderer(fg_ren) renwin.AddRenderer(bg_ren)
p8 = [0.0, 0.0, 0.0] p9 = [1, 1.0, 1.0] # Add the points to a vtkPoints object points = vtk.vtkPoints() pid = points.InsertNextPoint(p0) points.InsertNextPoint(p1) points.InsertNextPoint(p2) points.InsertNextPoint(p3) points.InsertNextPoint(p4) points.InsertNextPoint(p5) points.InsertNextPoint(p6) points.InsertNextPoint(p7) # Create a quad on the four points quad = vtk.vtkQuad() quad.GetPointIds().SetId(0, 0) quad.GetPointIds().SetId(1, 1) quad.GetPointIds().SetId(2, 2) quad.GetPointIds().SetId(3, 3) quad2 = vtk.vtkQuad() quad2.GetPointIds().SetId(0, 4) quad2.GetPointIds().SetId(1, 5) quad2.GetPointIds().SetId(2, 6) quad2.GetPointIds().SetId(3, 7) points.InsertNextPoint(p8) pid = points.InsertNextPoint(p9) line = vtk.vtkLine()
def load_avl_geometry(self, avl_filename, name='main', plot=True): model_name = name #key = self.case_keys[self.icase] #case = self.result_cases[key] #skip_reading = self._remove_old_adb_geometry(adb_filename) #if skip_reading: #return log = self.gui.log model = read_avl(avl_filename, log=log, debug=False) self.gui.model_type = 'avl' nodes, elements, line_elements, surfaces = model.get_nodes_elements() #self.model_type = model.model_type nxyz_nodes = nodes.shape[0] nquad_elements = elements.shape[0] nline_elements = 0 if line_elements: nline_elements = line_elements.shape[0] assert nline_elements > 0, nline_elements nnodes = nxyz_nodes nelements = nquad_elements + nline_elements self.gui.nnodes = nnodes self.gui.nelements = nelements grid = self.gui.grid grid.Allocate(self.gui.nelements, 1000) points = vtk.vtkPoints() points.SetNumberOfPoints(self.gui.nnodes) #vectorReselt.SetNumberOfComponents(3) self.gui.nid_map = {} assert nodes is not None nid = 0 #print('nxyz_nodes=%s' % nxyz_nodes) mmax = amax(nodes, axis=0) mmin = amin(nodes, axis=0) dim_max = (mmax - mmin).max() self.gui.create_global_axes(dim_max) for i in range(nxyz_nodes): points.InsertPoint(nid, nodes[i, :]) nid += 1 log.info('nnodes=%s nquad_elements=%s nline_elements=%s' % ( nxyz_nodes, nquad_elements, nline_elements)) #elements -= 1 for eid in range(nquad_elements): elem = vtkQuad() node_ids = elements[eid, :] point_ids = elem.GetPointIds() point_ids.SetId(0, node_ids[0]) point_ids.SetId(1, node_ids[1]) point_ids.SetId(2, node_ids[2]) point_ids.SetId(3, node_ids[3]) grid.InsertNextCell(elem.GetCellType(), point_ids) for eid in range(nline_elements): elem = vtkLine() node_ids = line_elements[eid, :] point_ids = elem.GetPointIds() point_ids.SetId(0, node_ids[0]) point_ids.SetId(1, node_ids[1]) grid.InsertNextCell(elem.GetCellType(), point_ids) grid.SetPoints(points) grid.Modified() # load results - regions/loads self.gui.scalar_bar_actor.VisibilityOn() self.gui.scalar_bar_actor.Modified() note = '' self.gui.isubcase_name_map = {1: ['AVL%s' % note, '']} cases = OrderedDict() ID = 1 form, cases, node_ids, element_ids = self._fill_avl_case( cases, ID, nnodes, nelements, surfaces) self.gui.node_ids = node_ids self.gui.element_ids = element_ids self.gui._finish_results_io2(model_name, form, cases)
def SimpleFindStrips(poly, coord): # Just do the cells in their given order # This method reduces the number of polys in the 20x20x20 by a factor of 3.623 # reduces the number of polys in the 100x100x100 by 2.216 #dirs=[0,1,2] #dirs.remove(coord) bounds = poly.GetBounds() numCells = poly.GetNumberOfCells() current = vtk.vtkGenericCell() newcell = vtk.vtkGenericCell() poly.GetCell(0, current) sharedpts = vtk.vtkIdList() sharedpts.DeepCopy(current.GetPointIds()) newPoints = vtk.vtkPoints() newPoints.DeepCopy(poly.GetPoints()) consolidatedpoly = vtk.vtkPolyData() consolidatedpoly.Allocate(1000,1000) consolidatedpoly.SetPoints(newPoints) x = [0,0,0] for i in xrange(1,numCells): poly.GetCell(i, newcell) # check if this cell shares an edge sharedpts.IntersectWith(newcell.GetPointIds()) # if they share an edge, the current cell becomes the union of the 2 cells if sharedpts.GetNumberOfIds() == 2: quad = vtk.vtkQuad() ptIds = [] for j in xrange(4): if sharedpts.IsId(current.GetPointIds().GetId(j)) == -1: ptIds.append(j) if ptIds == [0,3]: ptIds.reverse() current.GetPoints().GetPoint(ptIds[0],x) quad.GetPointIds().InsertId(0,current.GetPointIds().GetId(ptIds[0])) quad.GetPoints().InsertPoint(0,x) current.GetPoints().GetPoint(ptIds[1],x) quad.GetPointIds().InsertId(1,current.GetPointIds().GetId(ptIds[1])) quad.GetPoints().InsertPoint(1,x) ptIds = [] for j in xrange(4): if sharedpts.IsId(newcell.GetPointIds().GetId(j)) == -1: ptIds.append(j) if ptIds == [0,3]: ptIds.reverse() newcell.GetPoints().GetPoint(ptIds[0],x) quad.GetPointIds().InsertId(2,newcell.GetPointIds().GetId(ptIds[0])) quad.GetPoints().InsertPoint(2,x) newcell.GetPoints().GetPoint(ptIds[1],x) quad.GetPointIds().InsertId(3,newcell.GetPointIds().GetId(ptIds[1])) quad.GetPoints().InsertPoint(3,x) current.DeepCopy(quad) #consolidatedpoly.InsertNextCell(current.GetCellType(),current.GetPointIds()) else: consolidatedpoly.InsertNextCell(current.GetCellType(),current.GetPointIds()) current.DeepCopy(newcell) sharedpts.DeepCopy(current.GetPointIds()) consolidatedpoly.InsertNextCell(current.GetCellType(),current.GetPointIds()) cleaner = vtk.vtkCleanPolyData() cleaner.SetInput(consolidatedpoly) consolidatedpoly = cleaner.GetOutput() consolidatedpoly.Squeeze() consolidatedpoly.Update() return consolidatedpoly
def readAbaqusMeshFromINP( mesh_filename, elem_types="all", verbose=1): myVTK.myPrint(verbose, "*** readAbaqusMeshFromINP: " + mesh_filename + " ***") points = vtk.vtkPoints() cell_array = vtk.vtkCellArray() mesh_file = open(mesh_filename, "r") context = "" for line in mesh_file: if (line[-1:] == "\n"): line = line[:-1] #myVTK.myPrint(verbose, "line =", line) if line.startswith("**"): continue if (context == "reading nodes"): if line.startswith("*"): context = "" else: splitted_line = line.split(",") points.InsertNextPoint([float(coord) for coord in splitted_line[1:4]]) if (context == "reading elems"): if line.startswith("*"): context = "" else: splitted_line = line.split(",") assert (len(splitted_line) == 1+cell_n_points), "Wrong number of elements in line. Aborting." for k_point in xrange(cell_n_points): cell.GetPointIds().SetId(k_point, int(splitted_line[1+k_point])-1) cell_array.InsertNextCell(cell) if line.startswith("*NODE"): context = "reading nodes" if line.startswith("*ELEMENT"): if ("TYPE=F3D4" in line) and (("quad" in elem_types) or ("all" in elem_types)): context = "reading elems" cell_vtk_type = vtk.VTK_QUAD cell_n_points = 4 cell = vtk.vtkQuad() elif ("TYPE=C3D4" in line) and (("tet" in elem_types) or ("all" in elem_types)): context = "reading elems" cell_vtk_type = vtk.VTK_TETRA cell_n_points = 4 cell = vtk.vtkTetra() elif ("TYPE=C3D8" in line) and (("hex" in elem_types) or ("all" in elem_types)): context = "reading elems" cell_vtk_type = vtk.VTK_HEXAHEDRON cell_n_points = 8 cell = vtk.vtkHexahedron() else: print "Warning: elements not read: " + line + "." mesh_file.close() ugrid = vtk.vtkUnstructuredGrid() ugrid.SetPoints(points) ugrid.SetCells(cell_vtk_type, cell_array) myVTK.myPrint(verbose, "n_cells = " + str(ugrid.GetNumberOfCells())) return ugrid
def testCells(self): # Demonstrates all cell types # # NOTE: the use of NewInstance/DeepCopy is included to increase # regression coverage. It is not required in most applications. ren = vtk.vtkRenderer() # turn off all cullers ren.GetCullers().RemoveAllItems() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) renWin.SetSize(300, 150) iRen = vtk.vtkRenderWindowInteractor() iRen.SetRenderWindow(renWin); # create a scene with one of each cell type # Voxel voxelPoints = vtk.vtkPoints() voxelPoints.SetNumberOfPoints(8) voxelPoints.InsertPoint(0, 0, 0, 0) voxelPoints.InsertPoint(1, 1, 0, 0) voxelPoints.InsertPoint(2, 0, 1, 0) voxelPoints.InsertPoint(3, 1, 1, 0) voxelPoints.InsertPoint(4, 0, 0, 1) voxelPoints.InsertPoint(5, 1, 0, 1) voxelPoints.InsertPoint(6, 0, 1, 1) voxelPoints.InsertPoint(7, 1, 1, 1) aVoxel = vtk.vtkVoxel() aVoxel.GetPointIds().SetId(0, 0) aVoxel.GetPointIds().SetId(1, 1) aVoxel.GetPointIds().SetId(2, 2) aVoxel.GetPointIds().SetId(3, 3) aVoxel.GetPointIds().SetId(4, 4) aVoxel.GetPointIds().SetId(5, 5) aVoxel.GetPointIds().SetId(6, 6) aVoxel.GetPointIds().SetId(7, 7) bVoxel = aVoxel.NewInstance() bVoxel.DeepCopy(aVoxel) aVoxelGrid = vtk.vtkUnstructuredGrid() aVoxelGrid.Allocate(1, 1) aVoxelGrid.InsertNextCell(aVoxel.GetCellType(), aVoxel.GetPointIds()) aVoxelGrid.SetPoints(voxelPoints) aVoxelMapper = vtk.vtkDataSetMapper() aVoxelMapper.SetInputData(aVoxelGrid) aVoxelActor = vtk.vtkActor() aVoxelActor.SetMapper(aVoxelMapper) aVoxelActor.GetProperty().BackfaceCullingOn() # Hexahedron hexahedronPoints = vtk.vtkPoints() hexahedronPoints.SetNumberOfPoints(8) hexahedronPoints.InsertPoint(0, 0, 0, 0) hexahedronPoints.InsertPoint(1, 1, 0, 0) hexahedronPoints.InsertPoint(2, 1, 1, 0) hexahedronPoints.InsertPoint(3, 0, 1, 0) hexahedronPoints.InsertPoint(4, 0, 0, 1) hexahedronPoints.InsertPoint(5, 1, 0, 1) hexahedronPoints.InsertPoint(6, 1, 1, 1) hexahedronPoints.InsertPoint(7, 0, 1, 1) aHexahedron = vtk.vtkHexahedron() aHexahedron.GetPointIds().SetId(0, 0) aHexahedron.GetPointIds().SetId(1, 1) aHexahedron.GetPointIds().SetId(2, 2) aHexahedron.GetPointIds().SetId(3, 3) aHexahedron.GetPointIds().SetId(4, 4) aHexahedron.GetPointIds().SetId(5, 5) aHexahedron.GetPointIds().SetId(6, 6) aHexahedron.GetPointIds().SetId(7, 7) bHexahedron = aHexahedron.NewInstance() bHexahedron.DeepCopy(aHexahedron) aHexahedronGrid = vtk.vtkUnstructuredGrid() aHexahedronGrid.Allocate(1, 1) aHexahedronGrid.InsertNextCell(aHexahedron.GetCellType(), aHexahedron.GetPointIds()) aHexahedronGrid.SetPoints(hexahedronPoints) aHexahedronMapper = vtk.vtkDataSetMapper() aHexahedronMapper.SetInputData(aHexahedronGrid) aHexahedronActor = vtk.vtkActor() aHexahedronActor.SetMapper(aHexahedronMapper) aHexahedronActor.AddPosition(2, 0, 0) aHexahedronActor.GetProperty().BackfaceCullingOn() # Tetra tetraPoints = vtk.vtkPoints() tetraPoints.SetNumberOfPoints(4) tetraPoints.InsertPoint(0, 0, 0, 0) tetraPoints.InsertPoint(1, 1, 0, 0) tetraPoints.InsertPoint(2, .5, 1, 0) tetraPoints.InsertPoint(3, .5, .5, 1) aTetra = vtk.vtkTetra() aTetra.GetPointIds().SetId(0, 0) aTetra.GetPointIds().SetId(1, 1) aTetra.GetPointIds().SetId(2, 2) aTetra.GetPointIds().SetId(3, 3) bTetra = aTetra.NewInstance() bTetra.DeepCopy(aTetra) aTetraGrid = vtk.vtkUnstructuredGrid() aTetraGrid.Allocate(1, 1) aTetraGrid.InsertNextCell(aTetra.GetCellType(), aTetra.GetPointIds()) aTetraGrid.SetPoints(tetraPoints) aTetraCopy = vtk.vtkUnstructuredGrid() aTetraCopy.ShallowCopy(aTetraGrid) aTetraMapper = vtk.vtkDataSetMapper() aTetraMapper.SetInputData(aTetraCopy) aTetraActor = vtk.vtkActor() aTetraActor.SetMapper(aTetraMapper) aTetraActor.AddPosition(4, 0, 0) aTetraActor.GetProperty().BackfaceCullingOn() # Wedge wedgePoints = vtk.vtkPoints() wedgePoints.SetNumberOfPoints(6) wedgePoints.InsertPoint(0, 0, 1, 0) wedgePoints.InsertPoint(1, 0, 0, 0) wedgePoints.InsertPoint(2, 0, .5, .5) wedgePoints.InsertPoint(3, 1, 1, 0) wedgePoints.InsertPoint(4, 1, 0, 0) wedgePoints.InsertPoint(5, 1, .5, .5) aWedge = vtk.vtkWedge() aWedge.GetPointIds().SetId(0, 0) aWedge.GetPointIds().SetId(1, 1) aWedge.GetPointIds().SetId(2, 2) aWedge.GetPointIds().SetId(3, 3) aWedge.GetPointIds().SetId(4, 4) aWedge.GetPointIds().SetId(5, 5) bWedge = aWedge.NewInstance() bWedge.DeepCopy(aWedge) aWedgeGrid = vtk.vtkUnstructuredGrid() aWedgeGrid.Allocate(1, 1) aWedgeGrid.InsertNextCell(aWedge.GetCellType(), aWedge.GetPointIds()) aWedgeGrid.SetPoints(wedgePoints) aWedgeCopy = vtk.vtkUnstructuredGrid() aWedgeCopy.DeepCopy(aWedgeGrid) aWedgeMapper = vtk.vtkDataSetMapper() aWedgeMapper.SetInputData(aWedgeCopy) aWedgeActor = vtk.vtkActor() aWedgeActor.SetMapper(aWedgeMapper) aWedgeActor.AddPosition(6, 0, 0) aWedgeActor.GetProperty().BackfaceCullingOn() # Pyramid pyramidPoints = vtk.vtkPoints() pyramidPoints.SetNumberOfPoints(5) pyramidPoints.InsertPoint(0, 0, 0, 0) pyramidPoints.InsertPoint(1, 1, 0, 0) pyramidPoints.InsertPoint(2, 1, 1, 0) pyramidPoints.InsertPoint(3, 0, 1, 0) pyramidPoints.InsertPoint(4, .5, .5, 1) aPyramid = vtk.vtkPyramid() aPyramid.GetPointIds().SetId(0, 0) aPyramid.GetPointIds().SetId(1, 1) aPyramid.GetPointIds().SetId(2, 2) aPyramid.GetPointIds().SetId(3, 3) aPyramid.GetPointIds().SetId(4, 4) bPyramid = aPyramid.NewInstance() bPyramid.DeepCopy(aPyramid) aPyramidGrid = vtk.vtkUnstructuredGrid() aPyramidGrid.Allocate(1, 1) aPyramidGrid.InsertNextCell(aPyramid.GetCellType(), aPyramid.GetPointIds()) aPyramidGrid.SetPoints(pyramidPoints) aPyramidMapper = vtk.vtkDataSetMapper() aPyramidMapper.SetInputData(aPyramidGrid) aPyramidActor = vtk.vtkActor() aPyramidActor.SetMapper(aPyramidMapper) aPyramidActor.AddPosition(8, 0, 0) aPyramidActor.GetProperty().BackfaceCullingOn() # Pixel pixelPoints = vtk.vtkPoints() pixelPoints.SetNumberOfPoints(4) pixelPoints.InsertPoint(0, 0, 0, 0) pixelPoints.InsertPoint(1, 1, 0, 0) pixelPoints.InsertPoint(2, 0, 1, 0) pixelPoints.InsertPoint(3, 1, 1, 0) aPixel = vtk.vtkPixel() aPixel.GetPointIds().SetId(0, 0) aPixel.GetPointIds().SetId(1, 1) aPixel.GetPointIds().SetId(2, 2) aPixel.GetPointIds().SetId(3, 3) bPixel = aPixel.NewInstance() bPixel.DeepCopy(aPixel) aPixelGrid = vtk.vtkUnstructuredGrid() aPixelGrid.Allocate(1, 1) aPixelGrid.InsertNextCell(aPixel.GetCellType(), aPixel.GetPointIds()) aPixelGrid.SetPoints(pixelPoints) aPixelMapper = vtk.vtkDataSetMapper() aPixelMapper.SetInputData(aPixelGrid) aPixelActor = vtk.vtkActor() aPixelActor.SetMapper(aPixelMapper) aPixelActor.AddPosition(0, 0, 2) aPixelActor.GetProperty().BackfaceCullingOn() # Quad quadPoints = vtk.vtkPoints() quadPoints.SetNumberOfPoints(4) quadPoints.InsertPoint(0, 0, 0, 0) quadPoints.InsertPoint(1, 1, 0, 0) quadPoints.InsertPoint(2, 1, 1, 0) quadPoints.InsertPoint(3, 0, 1, 0) aQuad = vtk.vtkQuad() aQuad.GetPointIds().SetId(0, 0) aQuad.GetPointIds().SetId(1, 1) aQuad.GetPointIds().SetId(2, 2) aQuad.GetPointIds().SetId(3, 3) bQuad = aQuad.NewInstance() bQuad.DeepCopy(aQuad) aQuadGrid = vtk.vtkUnstructuredGrid() aQuadGrid.Allocate(1, 1) aQuadGrid.InsertNextCell(aQuad.GetCellType(), aQuad.GetPointIds()) aQuadGrid.SetPoints(quadPoints) aQuadMapper = vtk.vtkDataSetMapper() aQuadMapper.SetInputData(aQuadGrid) aQuadActor = vtk.vtkActor() aQuadActor.SetMapper(aQuadMapper) aQuadActor.AddPosition(2, 0, 2) aQuadActor.GetProperty().BackfaceCullingOn() # Triangle trianglePoints = vtk.vtkPoints() trianglePoints.SetNumberOfPoints(3) trianglePoints.InsertPoint(0, 0, 0, 0) trianglePoints.InsertPoint(1, 1, 0, 0) trianglePoints.InsertPoint(2, .5, .5, 0) triangleTCoords = vtk.vtkFloatArray() triangleTCoords.SetNumberOfComponents(2) triangleTCoords.SetNumberOfTuples(3) triangleTCoords.InsertTuple2(0, 1, 1) triangleTCoords.InsertTuple2(1, 2, 2) triangleTCoords.InsertTuple2(2, 3, 3) aTriangle = vtk.vtkTriangle() aTriangle.GetPointIds().SetId(0, 0) aTriangle.GetPointIds().SetId(1, 1) aTriangle.GetPointIds().SetId(2, 2) bTriangle = aTriangle.NewInstance() bTriangle.DeepCopy(aTriangle) aTriangleGrid = vtk.vtkUnstructuredGrid() aTriangleGrid.Allocate(1, 1) aTriangleGrid.InsertNextCell(aTriangle.GetCellType(), aTriangle.GetPointIds()) aTriangleGrid.SetPoints(trianglePoints) aTriangleGrid.GetPointData().SetTCoords(triangleTCoords) aTriangleMapper = vtk.vtkDataSetMapper() aTriangleMapper.SetInputData(aTriangleGrid) aTriangleActor = vtk.vtkActor() aTriangleActor.SetMapper(aTriangleMapper) aTriangleActor.AddPosition(4, 0, 2) aTriangleActor.GetProperty().BackfaceCullingOn() # Polygon polygonPoints = vtk.vtkPoints() polygonPoints.SetNumberOfPoints(4) polygonPoints.InsertPoint(0, 0, 0, 0) polygonPoints.InsertPoint(1, 1, 0, 0) polygonPoints.InsertPoint(2, 1, 1, 0) polygonPoints.InsertPoint(3, 0, 1, 0) aPolygon = vtk.vtkPolygon() aPolygon.GetPointIds().SetNumberOfIds(4) aPolygon.GetPointIds().SetId(0, 0) aPolygon.GetPointIds().SetId(1, 1) aPolygon.GetPointIds().SetId(2, 2) aPolygon.GetPointIds().SetId(3, 3) bPolygon = aPolygon.NewInstance() bPolygon.DeepCopy(aPolygon) aPolygonGrid = vtk.vtkUnstructuredGrid() aPolygonGrid.Allocate(1, 1) aPolygonGrid.InsertNextCell(aPolygon.GetCellType(), aPolygon.GetPointIds()) aPolygonGrid.SetPoints(polygonPoints) aPolygonMapper = vtk.vtkDataSetMapper() aPolygonMapper.SetInputData(aPolygonGrid) aPolygonActor = vtk.vtkActor() aPolygonActor.SetMapper(aPolygonMapper) aPolygonActor.AddPosition(6, 0, 2) aPolygonActor.GetProperty().BackfaceCullingOn() # Triangle Strip triangleStripPoints = vtk.vtkPoints() triangleStripPoints.SetNumberOfPoints(5) triangleStripPoints.InsertPoint(0, 0, 1, 0) triangleStripPoints.InsertPoint(1, 0, 0, 0) triangleStripPoints.InsertPoint(2, 1, 1, 0) triangleStripPoints.InsertPoint(3, 1, 0, 0) triangleStripPoints.InsertPoint(4, 2, 1, 0) triangleStripTCoords = vtk.vtkFloatArray() triangleStripTCoords.SetNumberOfComponents(2) triangleStripTCoords.SetNumberOfTuples(3) triangleStripTCoords.InsertTuple2(0, 1, 1) triangleStripTCoords.InsertTuple2(1, 2, 2) triangleStripTCoords.InsertTuple2(2, 3, 3) triangleStripTCoords.InsertTuple2(3, 4, 4) triangleStripTCoords.InsertTuple2(4, 5, 5) aTriangleStrip = vtk.vtkTriangleStrip() aTriangleStrip.GetPointIds().SetNumberOfIds(5) aTriangleStrip.GetPointIds().SetId(0, 0) aTriangleStrip.GetPointIds().SetId(1, 1) aTriangleStrip.GetPointIds().SetId(2, 2) aTriangleStrip.GetPointIds().SetId(3, 3) aTriangleStrip.GetPointIds().SetId(4, 4) bTriangleStrip = aTriangleStrip.NewInstance() bTriangleStrip.DeepCopy(aTriangleStrip) aTriangleStripGrid = vtk.vtkUnstructuredGrid() aTriangleStripGrid.Allocate(1, 1) aTriangleStripGrid.InsertNextCell(aTriangleStrip.GetCellType(), aTriangleStrip.GetPointIds()) aTriangleStripGrid.SetPoints(triangleStripPoints) aTriangleStripGrid.GetPointData().SetTCoords(triangleStripTCoords) aTriangleStripMapper = vtk.vtkDataSetMapper() aTriangleStripMapper.SetInputData(aTriangleStripGrid) aTriangleStripActor = vtk.vtkActor() aTriangleStripActor.SetMapper(aTriangleStripMapper) aTriangleStripActor.AddPosition(8, 0, 2) aTriangleStripActor.GetProperty().BackfaceCullingOn() # Line linePoints = vtk.vtkPoints() linePoints.SetNumberOfPoints(2) linePoints.InsertPoint(0, 0, 0, 0) linePoints.InsertPoint(1, 1, 1, 0) aLine = vtk.vtkLine() aLine.GetPointIds().SetId(0, 0) aLine.GetPointIds().SetId(1, 1) bLine = aLine.NewInstance() bLine.DeepCopy(aLine) aLineGrid = vtk.vtkUnstructuredGrid() aLineGrid.Allocate(1, 1) aLineGrid.InsertNextCell(aLine.GetCellType(), aLine.GetPointIds()) aLineGrid.SetPoints(linePoints) aLineMapper = vtk.vtkDataSetMapper() aLineMapper.SetInputData(aLineGrid) aLineActor = vtk.vtkActor() aLineActor.SetMapper(aLineMapper) aLineActor.AddPosition(0, 0, 4) aLineActor.GetProperty().BackfaceCullingOn() # Poly line polyLinePoints = vtk.vtkPoints() polyLinePoints.SetNumberOfPoints(3) polyLinePoints.InsertPoint(0, 0, 0, 0) polyLinePoints.InsertPoint(1, 1, 1, 0) polyLinePoints.InsertPoint(2, 1, 0, 0) aPolyLine = vtk.vtkPolyLine() aPolyLine.GetPointIds().SetNumberOfIds(3) aPolyLine.GetPointIds().SetId(0, 0) aPolyLine.GetPointIds().SetId(1, 1) aPolyLine.GetPointIds().SetId(2, 2) bPolyLine = aPolyLine.NewInstance() bPolyLine.DeepCopy(aPolyLine) aPolyLineGrid = vtk.vtkUnstructuredGrid() aPolyLineGrid.Allocate(1, 1) aPolyLineGrid.InsertNextCell(aPolyLine.GetCellType(), aPolyLine.GetPointIds()) aPolyLineGrid.SetPoints(polyLinePoints) aPolyLineMapper = vtk.vtkDataSetMapper() aPolyLineMapper.SetInputData(aPolyLineGrid) aPolyLineActor = vtk.vtkActor() aPolyLineActor.SetMapper(aPolyLineMapper) aPolyLineActor.AddPosition(2, 0, 4) aPolyLineActor.GetProperty().BackfaceCullingOn() # Vertex vertexPoints = vtk.vtkPoints() vertexPoints.SetNumberOfPoints(1) vertexPoints.InsertPoint(0, 0, 0, 0) aVertex = vtk.vtkVertex() aVertex.GetPointIds().SetId(0, 0) bVertex = aVertex.NewInstance() bVertex.DeepCopy(aVertex) aVertexGrid = vtk.vtkUnstructuredGrid() aVertexGrid.Allocate(1, 1) aVertexGrid.InsertNextCell(aVertex.GetCellType(), aVertex.GetPointIds()) aVertexGrid.SetPoints(vertexPoints) aVertexMapper = vtk.vtkDataSetMapper() aVertexMapper.SetInputData(aVertexGrid) aVertexActor = vtk.vtkActor() aVertexActor.SetMapper(aVertexMapper) aVertexActor.AddPosition(0, 0, 6) aVertexActor.GetProperty().BackfaceCullingOn() # Poly Vertex polyVertexPoints = vtk.vtkPoints() polyVertexPoints.SetNumberOfPoints(3) polyVertexPoints.InsertPoint(0, 0, 0, 0) polyVertexPoints.InsertPoint(1, 1, 0, 0) polyVertexPoints.InsertPoint(2, 1, 1, 0) aPolyVertex = vtk.vtkPolyVertex() aPolyVertex.GetPointIds().SetNumberOfIds(3) aPolyVertex.GetPointIds().SetId(0, 0) aPolyVertex.GetPointIds().SetId(1, 1) aPolyVertex.GetPointIds().SetId(2, 2) bPolyVertex = aPolyVertex.NewInstance() bPolyVertex.DeepCopy(aPolyVertex) aPolyVertexGrid = vtk.vtkUnstructuredGrid() aPolyVertexGrid.Allocate(1, 1) aPolyVertexGrid.InsertNextCell(aPolyVertex.GetCellType(), aPolyVertex.GetPointIds()) aPolyVertexGrid.SetPoints(polyVertexPoints) aPolyVertexMapper = vtk.vtkDataSetMapper() aPolyVertexMapper.SetInputData(aPolyVertexGrid) aPolyVertexActor = vtk.vtkActor() aPolyVertexActor.SetMapper(aPolyVertexMapper) aPolyVertexActor.AddPosition(2, 0, 6) aPolyVertexActor.GetProperty().BackfaceCullingOn() # Pentagonal prism pentaPoints = vtk.vtkPoints() pentaPoints.SetNumberOfPoints(10) pentaPoints.InsertPoint(0, 0.25, 0.0, 0.0) pentaPoints.InsertPoint(1, 0.75, 0.0, 0.0) pentaPoints.InsertPoint(2, 1.0, 0.5, 0.0) pentaPoints.InsertPoint(3, 0.5, 1.0, 0.0) pentaPoints.InsertPoint(4, 0.0, 0.5, 0.0) pentaPoints.InsertPoint(5, 0.25, 0.0, 1.0) pentaPoints.InsertPoint(6, 0.75, 0.0, 1.0) pentaPoints.InsertPoint(7, 1.0, 0.5, 1.0) pentaPoints.InsertPoint(8, 0.5, 1.0, 1.0) pentaPoints.InsertPoint(9, 0.0, 0.5, 1.0) aPenta = vtk.vtkPentagonalPrism() aPenta.GetPointIds().SetId(0, 0) aPenta.GetPointIds().SetId(1, 1) aPenta.GetPointIds().SetId(2, 2) aPenta.GetPointIds().SetId(3, 3) aPenta.GetPointIds().SetId(4, 4) aPenta.GetPointIds().SetId(5, 5) aPenta.GetPointIds().SetId(6, 6) aPenta.GetPointIds().SetId(7, 7) aPenta.GetPointIds().SetId(8, 8) aPenta.GetPointIds().SetId(9, 9) bPenta = aPenta.NewInstance() bPenta.DeepCopy(aPenta) aPentaGrid = vtk.vtkUnstructuredGrid() aPentaGrid.Allocate(1, 1) aPentaGrid.InsertNextCell(aPenta.GetCellType(), aPenta.GetPointIds()) aPentaGrid.SetPoints(pentaPoints) aPentaCopy = vtk.vtkUnstructuredGrid() aPentaCopy.DeepCopy(aPentaGrid) aPentaMapper = vtk.vtkDataSetMapper() aPentaMapper.SetInputData(aPentaCopy) aPentaActor = vtk.vtkActor() aPentaActor.SetMapper(aPentaMapper) aPentaActor.AddPosition(10, 0, 0) aPentaActor.GetProperty().BackfaceCullingOn() # Hexagonal prism hexaPoints = vtk.vtkPoints() hexaPoints.SetNumberOfPoints(12) hexaPoints.InsertPoint(0, 0.0, 0.0, 0.0) hexaPoints.InsertPoint(1, 0.5, 0.0, 0.0) hexaPoints.InsertPoint(2, 1.0, 0.5, 0.0) hexaPoints.InsertPoint(3, 1.0, 1.0, 0.0) hexaPoints.InsertPoint(4, 0.5, 1.0, 0.0) hexaPoints.InsertPoint(5, 0.0, 0.5, 0.0) hexaPoints.InsertPoint(6, 0.0, 0.0, 1.0) hexaPoints.InsertPoint(7, 0.5, 0.0, 1.0) hexaPoints.InsertPoint(8, 1.0, 0.5, 1.0) hexaPoints.InsertPoint(9, 1.0, 1.0, 1.0) hexaPoints.InsertPoint(10, 0.5, 1.0, 1.0) hexaPoints.InsertPoint(11, 0.0, 0.5, 1.0) aHexa = vtk.vtkHexagonalPrism() aHexa.GetPointIds().SetId(0, 0) aHexa.GetPointIds().SetId(1, 1) aHexa.GetPointIds().SetId(2, 2) aHexa.GetPointIds().SetId(3, 3) aHexa.GetPointIds().SetId(4, 4) aHexa.GetPointIds().SetId(5, 5) aHexa.GetPointIds().SetId(6, 6) aHexa.GetPointIds().SetId(7, 7) aHexa.GetPointIds().SetId(8, 8) aHexa.GetPointIds().SetId(9, 9) aHexa.GetPointIds().SetId(10, 10) aHexa.GetPointIds().SetId(11, 11) bHexa = aHexa.NewInstance() bHexa.DeepCopy(aHexa) aHexaGrid = vtk.vtkUnstructuredGrid() aHexaGrid.Allocate(1, 1) aHexaGrid.InsertNextCell(aHexa.GetCellType(), aHexa.GetPointIds()) aHexaGrid.SetPoints(hexaPoints) aHexaCopy = vtk.vtkUnstructuredGrid() aHexaCopy.DeepCopy(aHexaGrid) aHexaMapper = vtk.vtkDataSetMapper() aHexaMapper.SetInputData(aHexaCopy) aHexaActor = vtk.vtkActor() aHexaActor.SetMapper(aHexaMapper) aHexaActor.AddPosition(12, 0, 0) aHexaActor.GetProperty().BackfaceCullingOn() # RIB property if hasattr(vtk, 'vtkRIBProperty'): aRIBProperty = vtk.vtkRIBProperty() aRIBProperty.SetVariable("Km", "float") aRIBProperty.SetSurfaceShader("LGVeinedmarble") aRIBProperty.SetVariable("veinfreq", "float") aRIBProperty.AddVariable("warpfreq", "float") aRIBProperty.AddVariable("veincolor", "color") aRIBProperty.AddParameter("veinfreq", " 2") aRIBProperty.AddParameter("veincolor", "1.0000 1.0000 0.9412") bRIBProperty = vtk.vtkRIBProperty() bRIBProperty.SetVariable("Km", "float") bRIBProperty.SetParameter("Km", "1.0") bRIBProperty.SetDisplacementShader("dented") bRIBProperty.SetSurfaceShader("plastic") aProperty = vtk.vtkProperty() bProperty = vtk.vtkProperty() aTriangleActor.SetProperty(aProperty) aTriangleStripActor.SetProperty(bProperty) ren.SetBackground(.1, .2, .4) ren.AddActor(aVoxelActor);aVoxelActor.GetProperty().SetDiffuseColor(1, 0, 0) ren.AddActor(aHexahedronActor);aHexahedronActor.GetProperty().SetDiffuseColor(1, 1, 0) ren.AddActor(aTetraActor);aTetraActor.GetProperty().SetDiffuseColor(0, 1, 0) ren.AddActor(aWedgeActor);aWedgeActor.GetProperty().SetDiffuseColor(0, 1, 1) ren.AddActor(aPyramidActor);aPyramidActor.GetProperty().SetDiffuseColor(1, 0, 1) ren.AddActor(aPixelActor);aPixelActor.GetProperty().SetDiffuseColor(0, 1, 1) ren.AddActor(aQuadActor);aQuadActor.GetProperty().SetDiffuseColor(1, 0, 1) ren.AddActor(aTriangleActor);aTriangleActor.GetProperty().SetDiffuseColor(.3, 1, .5) ren.AddActor(aPolygonActor);aPolygonActor.GetProperty().SetDiffuseColor(1, .4, .5) ren.AddActor(aTriangleStripActor);aTriangleStripActor.GetProperty().SetDiffuseColor(.3, .7, 1) ren.AddActor(aLineActor);aLineActor.GetProperty().SetDiffuseColor(.2, 1, 1) ren.AddActor(aPolyLineActor);aPolyLineActor.GetProperty().SetDiffuseColor(1, 1, 1) ren.AddActor(aVertexActor);aVertexActor.GetProperty().SetDiffuseColor(1, 1, 1) ren.AddActor(aPolyVertexActor);aPolyVertexActor.GetProperty().SetDiffuseColor(1, 1, 1) ren.AddActor(aPentaActor);aPentaActor.GetProperty().SetDiffuseColor(.2, .4, .7) ren.AddActor(aHexaActor);aHexaActor.GetProperty().SetDiffuseColor(.7, .5, 1) if hasattr(vtk, 'vtkRIBLight'): aRIBLight = vtk.vtkRIBLight() aRIBLight.ShadowsOn() aLight = vtk.vtkLight() aLight.PositionalOn() aLight.SetConeAngle(25) ren.AddLight(aLight) ren.ResetCamera() ren.GetActiveCamera().Azimuth(30) ren.GetActiveCamera().Elevation(20) ren.GetActiveCamera().Dolly(2.8) ren.ResetCameraClippingRange() aLight.SetFocalPoint(ren.GetActiveCamera().GetFocalPoint()) aLight.SetPosition(ren.GetActiveCamera().GetPosition()) # write to the temp directory if possible, otherwise use . dir = tempfile.gettempdir() atext = vtk.vtkTexture() pnmReader = vtk.vtkBMPReader() pnmReader.SetFileName(VTK_DATA_ROOT + "/Data/masonry.bmp") atext.SetInputConnection(pnmReader.GetOutputPort()) atext.InterpolateOff() aTriangleActor.SetTexture(atext) # bascially have IO/Export ? if hasattr(vtk, 'vtkRIBExporter'): rib = vtk.vtkRIBExporter() rib.SetInput(renWin) rib.SetFilePrefix(dir + '/cells') rib.SetTexturePrefix(dir + '/cells') rib.Write() os.remove(dir + '/cells.rib') iv = vtk.vtkIVExporter() iv.SetInput(renWin) iv.SetFileName(dir + "/cells.iv") iv.Write() os.remove(dir + '/cells.iv') obj = vtk.vtkOBJExporter() obj.SetInput(renWin) obj.SetFilePrefix(dir + "/cells") obj.Write() os.remove(dir + '/cells.obj') os.remove(dir + '/cells.mtl') vrml = vtk.vtkVRMLExporter() vrml.SetInput(renWin) #vrml.SetStartWrite(vrml.SetFileName(dir + "/cells.wrl")) #vrml.SetEndWrite(vrml.SetFileName("/a/acells.wrl")) vrml.SetFileName(dir + "/cells.wrl") vrml.SetSpeed(5.5) vrml.Write() os.remove(dir + '/cells.wrl') oogl = vtk.vtkOOGLExporter() oogl.SetInput(renWin) oogl.SetFileName(dir + "/cells.oogl") oogl.Write() os.remove(dir + '/cells.oogl') # the UnRegister calls are because make object is the same as New, # and causes memory leaks. (Python does not treat NewInstance the same as New). def DeleteCopies(): bVoxel.UnRegister(None) bHexahedron.UnRegister(None) bTetra.UnRegister(None) bWedge.UnRegister(None) bPyramid.UnRegister(None) bPixel.UnRegister(None) bQuad.UnRegister(None) bTriangle.UnRegister(None) bPolygon.UnRegister(None) bTriangleStrip.UnRegister(None) bLine.UnRegister(None) bPolyLine.UnRegister(None) bVertex.UnRegister(None) bPolyVertex.UnRegister(None) bPenta.UnRegister(None) bHexa.UnRegister(None) DeleteCopies() # render and interact with data renWin.Render() img_file = "cells.png" vtk.test.Testing.compareImage(iRen.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file), threshold=25) vtk.test.Testing.interact()
def load_degen_geom_geometry(self, csv_filename, dirname, name='main', plot=True): #key = self.case_keys[self.icase] #case = self.result_cases[key] skip_reading = self._remove_old_adb_geometry(csv_filename) if skip_reading: return model = DegenGeom(log=self.log, debug=False) self.model_type = 'vspaero' #self.model_type = model.model_type model.read_degen_geom(csv_filename) for name, comps in sorted(model.components.items()): print('name = %r' % name) #print(comp) print('------------') for comp in comps: nodes = comp.xyz elements = comp.elements nnodes = nodes.shape[0] nelements = elements.shape[0] self.nNodes = nnodes self.nElements = nelements self.grid.Allocate(self.nElements, 1000) #self.gridResult.SetNumberOfComponents(self.nElements) points = vtk.vtkPoints() points.SetNumberOfPoints(self.nNodes) #self.gridResult.Allocate(self.nNodes, 1000) #vectorReselt.SetNumberOfComponents(3) self.nid_map = {} assert nodes is not None nid = 0 #print("nxyz_nodes=%s" % nxyz_nodes) mmax = amax(nodes, axis=0) mmin = amin(nodes, axis=0) dim_max = (mmax - mmin).max() self.create_global_axes(dim_max) for i in range(nnodes): points.InsertPoint(nid, nodes[i, :]) nid += 1 #self.log.info('nxyz_nodes=%s nwake_nodes=%s total=%s' % ( #nnodes, nwake_nodes, nxyz_nodes + nwake_nodes)) #self.log.info('nxyz_elements=%s nwake_elements=%s total=%s' % ( #nxyz_elements, nwake_elements, nxyz_elements + nwake_elements)) elements -= 1 for eid in range(nelements): elem = vtkQuad() #assert elem.GetCellType() == 9, elem.GetCellType() node_ids = elements[eid, :] elem.GetPointIds().SetId(0, node_ids[0]) elem.GetPointIds().SetId(1, node_ids[1]) elem.GetPointIds().SetId(2, node_ids[2]) elem.GetPointIds().SetId(3, node_ids[3]) self.grid.InsertNextCell(9, elem.GetPointIds()) #elem.GetCellType() = 5 # vtkTriangle self.grid.SetPoints(points) self.grid.Modified() if hasattr(self.grid, 'Update'): self.grid.Update() print("updated grid") # load results - regions/loads self. turn_text_on() self.scalarBar.VisibilityOn() self.scalarBar.Modified() #mach = model.machs[0] #alpha = model.alphas[0] #beta = model.betas[0] #note = ': Mach=%.2f, alpha=%.1f, beta=%.1f' % (mach, alpha, beta) note = 'name=%s' % name self.iSubcaseNameMap = {1: ['OpenVSP%s' % note, '']} cases = {} ID = 1 form, cases = self._fill_degen_geom_case(cases, ID, model, nnodes, nelements) self._finish_results_io2(form, cases)
def load_panair_geometry(self, panair_filename, name='main', plot=True): model_name = name self.gui.nid_map = {} #key = self.case_keys[self.icase] #case = self.result_cases[key] skip_reading = self.gui._remove_old_geometry(panair_filename) if skip_reading: return model = PanairGrid(log=self.gui.log, debug=self.gui.debug) self.gui.model_type = model.model_type model.read_panair(panair_filename) self.gui.geom_model = model # get_wakes=True shows explicit wakes # # TODO: bad for results...what about just not adding it to the patches/bcs? nodes, elements, regions, kt, cp_norm = model.get_points_elements_regions( get_wakes=True) self.gui.nnodes = len(nodes) self.gui.nelements = len(elements) #print("nnodes = ",self.nnodes) #print("nelements = ", self.nelements) grid = self.gui.grid grid.Allocate(self.gui.nelements, 1000) points = vtk.vtkPoints() points.SetNumberOfPoints(self.gui.nnodes) assert len(nodes) > 0 mmax = amax(nodes, axis=0) mmin = amin(nodes, axis=0) dim_max = (mmax - mmin).max() self.gui.create_global_axes(dim_max) points = numpy_to_vtk_points(nodes) assert len(elements) > 0 elem = vtkQuad() quad_type = elem.GetCellType() create_vtk_cells_of_constant_element_type(grid, elements, quad_type) grid.SetPoints(points) grid.Modified() # loadPanairResults - regions/loads if plot: self.gui.scalar_bar_actor.VisibilityOn() self.gui.scalar_bar_actor.Modified() self.gui.isubcase_name_map = {1: ['Panair', '']} cases = OrderedDict() ID = 1 loads = [] form, cases, node_ids, element_ids = self._fill_panair_geometry_case( cases, ID, nodes, elements, regions, kt, cp_norm, loads) self.gui.node_ids = node_ids self.gui.element_ids = element_ids #if plot: self.gui._finish_results_io2(model_name, form, cases)
def rhombicuboctahedron(): import vtk # First, you need to store the vertex locations. import numpy as np fu = 1 # full unit hu = .5 # half unit d = np.sqrt((fu**2) / 2) # diag hh = hu + d # half height # left view faces us import utool as ut import six import itertools counter = ut.partial(six.next, itertools.count(0)) vertex_locations = vtk.vtkPoints() vertex_locations.SetNumberOfPoints(24) p1, p2, p3 = np.array([ (-hu, -hu, hh), (hu, -hu, hh), (hu, hu, hh), (-hu, hu, hh), ]).T plist = [p1, p2, p3] # three of the six main faces #perms = list(itertools.permutations((0, 1, 2), 3)) perms = [(0, 1, 2), (0, 2, 1), (2, 0, 1)] vertex_array = [] # VERTEXES # left, up, back vplist = ['L', 'U', 'B', 'R', 'D', 'F'] vpdict = {} print('perms = %r' % (perms, )) for x in range(3): vp = vplist[x] p = np.vstack(ut.take(plist, perms[x])).T counts = [counter() for z in range(4)] vpdict[vp] = counts vertex_array.extend(p.tolist()) vertex_locations.SetPoint(counts[0], p[0]) vertex_locations.SetPoint(counts[1], p[1]) vertex_locations.SetPoint(counts[2], p[2]) vertex_locations.SetPoint(counts[3], p[3]) # three more of the six main faces perms = [(0, 1, 2), (0, 2, 1), (2, 0, 1)] plist[-1] = -plist[-1] # right, down, front print('perms = %r' % (perms, )) for x in range(3): p = np.vstack(ut.take(plist, perms[x])).T counts = [counter() for z in range(4)] vp = vplist[x + 3] vpdict[vp] = counts vertex_array.extend(p.tolist()) vertex_locations.SetPoint(counts[0], p[0]) vertex_locations.SetPoint(counts[1], p[1]) vertex_locations.SetPoint(counts[2], p[2]) vertex_locations.SetPoint(counts[3], p[3]) pd = vtk.vtkPolyData() pd.SetPoints(vertex_locations) polygon_faces = vtk.vtkCellArray() face_dict = { 'L': [vpdict['L'][0], vpdict['L'][1], vpdict['L'][2], vpdict['L'][3]], 'D': [vpdict['D'][0], vpdict['D'][1], vpdict['D'][2], vpdict['D'][3]], 'U': [vpdict['U'][0], vpdict['U'][1], vpdict['U'][2], vpdict['U'][3]], 'F': [vpdict['F'][0], vpdict['F'][1], vpdict['F'][2], vpdict['F'][3]], 'R': [vpdict['R'][0], vpdict['R'][1], vpdict['R'][2], vpdict['R'][3]], 'B': [vpdict['B'][0], vpdict['B'][1], vpdict['B'][2], vpdict['B'][3]], 'FL': [ vpdict['L'][0], vpdict['L'][3], vpdict['F'][2], vpdict['F'][3], ], 'BL': [ vpdict['L'][1], vpdict['L'][2], vpdict['B'][2], vpdict['B'][3], ], 'UL': [ vpdict['L'][2], vpdict['L'][3], vpdict['U'][3], vpdict['U'][2], ], 'DL': [ vpdict['L'][0], vpdict['L'][1], vpdict['D'][2], vpdict['D'][3], ], 'UFL': [ vpdict['L'][3], vpdict['F'][2], vpdict['U'][3], ], 'DFL': [ vpdict['L'][0], vpdict['F'][3], vpdict['D'][3], ], 'UBL': [ vpdict['L'][2], vpdict['B'][2], vpdict['U'][2], ], 'DBL': [ vpdict['L'][1], vpdict['B'][3], vpdict['D'][2], ], 'UFR': [ vpdict['R'][3], vpdict['F'][1], vpdict['U'][0], ], 'DFR': [ vpdict['R'][0], vpdict['F'][0], vpdict['D'][0], ], 'UBR': [ vpdict['R'][2], vpdict['B'][1], vpdict['U'][1], ], 'DBR': [ vpdict['R'][1], vpdict['B'][0], vpdict['D'][1], ], 'FR': [ vpdict['R'][3], vpdict['R'][0], vpdict['F'][0], vpdict['F'][1], ], 'BR': [ vpdict['R'][2], vpdict['R'][1], vpdict['B'][0], vpdict['B'][1], ], 'UR': [ vpdict['R'][3], vpdict['R'][2], vpdict['U'][1], vpdict['U'][0], ], 'DR': [ vpdict['R'][1], vpdict['R'][0], vpdict['D'][0], vpdict['D'][1], ], 'DF': [ vpdict['F'][0], vpdict['F'][3], vpdict['D'][3], vpdict['D'][0], ], 'DB': [ vpdict['B'][3], vpdict['B'][0], vpdict['D'][1], vpdict['D'][2], ], 'UF': [ vpdict['F'][1], vpdict['F'][2], vpdict['U'][3], vpdict['U'][0], ], 'UB': [ vpdict['B'][2], vpdict['B'][1], vpdict['U'][1], vpdict['U'][2], ], } for key, vert_ids in face_dict.items(): #if key != 'L': # continue if len(vert_ids) == 4: q = vtk.vtkQuad() else: q = vtk.vtkTriangle() for count, idx in enumerate(vert_ids): q.GetPointIds().SetId(count, idx) polygon_faces.InsertNextCell(q) # Next you create a vtkPolyData to store your face and vertex information #that # represents your polyhedron. pd = vtk.vtkPolyData() pd.SetPoints(vertex_locations) pd.SetPolys(polygon_faces) face_stream = vtk.vtkIdList() face_stream.InsertNextId(polygon_faces.GetNumberOfCells()) vertex_list = vtk.vtkIdList() polygon_faces.InitTraversal() while polygon_faces.GetNextCell(vertex_list) == 1: face_stream.InsertNextId(vertex_list.GetNumberOfIds()) for j in range(vertex_list.GetNumberOfIds()): face_stream.InsertNextId(vertex_list.GetId(j)) ug = vtk.vtkUnstructuredGrid() ug.SetPoints(vertex_locations) ug.InsertNextCell(vtk.VTK_POLYHEDRON, face_stream) #writer = vtk.vtkUnstructuredGridWriter() #writer.SetFileName("rhombicuboctahedron.vtk") ##writer.SetInputData(ug) #writer.SetInput(ug) #writer.Write() mapper = vtk.vtkDataSetMapper() mapper.SetInput(ug) actor = vtk.vtkActor() actor.SetMapper(mapper) if 1: # Read the image data from a file import utool as ut textureCoords = vtk.vtkFloatArray() textureCoords.SetNumberOfComponents(3) #coords = ut.take(vertex_array, face_dict['L']) #for coord in coords: # textureCoords.InsertNextTuple(tuple(coord)) textureCoords.InsertNextTuple((0, 0, 0)) textureCoords.InsertNextTuple((1, 0, 0)) textureCoords.InsertNextTuple((1, 1, 0)) textureCoords.InsertNextTuple((0, 1, 0)) # Create texture object fpath = ut.grab_test_imgpath('zebra.png') reader = vtk.vtkPNGReader() reader.SetFileName(fpath) texture = vtk.vtkTexture() texture.SetInput(reader.GetOutput()) texture.RepeatOff() texture.InterpolateOff() ptdat = pd.GetPointData() ptdat.SetTCoords(textureCoords) actor.SetTexture(texture) ren = vtk.vtkRenderer() ren.AddActor(actor) renw = vtk.vtkRenderWindow() renw.AddRenderer(ren) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renw) ren.ResetCamera() renw.Render() iren.Start()
def load_openfoam_geometry(self, openfoam_filename, dirname, mesh_3d, plot=True): #key = self.caseKeys[self.iCase] #case = self.resultCases[key] skip_reading = self.remove_old_openfoam_geometry(openfoam_filename) if skip_reading: return #print('self.modelType=%s' % self.modelType) print('mesh_3d = %s' % mesh_3d) if mesh_3d in ['hex', 'shell']: model = BlockMesh(log=self.log, debug=False) # log=self.log, debug=False elif mesh_3d == 'faces': model = BlockMesh(log=self.log, debug=False) # log=self.log, debug=False boundary = Boundary(log=self.log, debug=False) self.modelType = 'openfoam' #self.modelType = model.modelType print('openfoam_filename = %s' % openfoam_filename) is_face_mesh = False if mesh_3d == 'hex': is_3d_blockmesh = True is_surface_blockmesh = False (nodes, hexas, quads, names, patches) = model.read_openfoam(openfoam_filename) elif mesh_3d == 'shell': is_3d_blockmesh = False is_surface_blockmesh = True (nodes, hexas, quads, names, patches) = model.read_openfoam(openfoam_filename) elif mesh_3d == 'faces': is_3d_blockmesh = False is_surface_blockmesh = False is_face_mesh = True #(nodes, hexas, quads, names, patches) = model.read_openfoam(openfoam_filename) else: raise RuntimeError(mesh_3d) tris = [] if mesh_3d == 'hex': self.nElements = len(hexas) elif mesh_3d == 'shell': self.nElements = len(quads) elif mesh_3d == 'faces': point_filename = os.path.join(dirname, 'points') face_filename = os.path.join(dirname, 'faces') boundary_filename = os.path.join(dirname, 'boundary') assert os.path.exists(face_filename), print_bad_path(face_filename) assert os.path.exists(point_filename), print_bad_path(point_filename) assert os.path.exists(boundary_filename), print_bad_path(boundary_filename) hexas = None patches = None nodes, quads, names = boundary.read_openfoam( point_filename, face_filename, boundary_filename) self.nElements = len(quads) + len(tris) else: raise RuntimeError(mesh_3d) self.nNodes = len(nodes) print("nNodes = %s" % self.nNodes) print("nElements = %s" % self.nElements) self.grid.Allocate(self.nElements, 1000) #self.gridResult.SetNumberOfComponents(self.nElements) self.grid2.Allocate(1, 1000) points = vtk.vtkPoints() points.SetNumberOfPoints(self.nNodes) #self.gridResult.Allocate(self.nNodes, 1000) #vectorReselt.SetNumberOfComponents(3) self.nidMap = {} #elem.SetNumberOfPoints(nNodes) if 0: fraction = 1. / self.nNodes # so you can color the nodes by ID for nid, node in sorted(iteritems(nodes)): points.InsertPoint(nid - 1, *node) self.gridResult.InsertNextValue(nid * fraction) #print(str(element)) #elem = vtk.vtkVertex() #elem.GetPointIds().SetId(0, i) #self.aQuadGrid.InsertNextCell(elem.GetCellType(), elem.GetPointIds()) #vectorResult.InsertTuple3(0, 0.0, 0.0, 1.0) assert nodes is not None nnodes, three = nodes.shape nid = 0 #print("nnodes=%s" % nnodes) mmax = amax(nodes, axis=0) mmin = amin(nodes, axis=0) dim_max = (mmax - mmin).max() self.update_axes_length(dim_max) f = open('points.bdf', 'wb') f.write('CEND\n') f.write('BEGIN BULK\n') unames = unique(names) for pid in unames: f.write('PSHELL,%i,1,0.1\n' % pid) f.write('MAT1,1,1.0e7,,0.3\n') if is_face_mesh: unodes = unique(quads) unodes.sort() # should stop plotting duplicate nodes for inode, node in enumerate(nodes): if inode in unodes: f.write('GRID,%i,,%s,%s,%s\n' % (inode + 1, node[0], node[1], node[2], )) points.InsertPoint(inode, node) else: #print(nodes) for inode, node in enumerate(nodes): points.InsertPoint(inode, node) #elements -= 1 normals = None if is_3d_blockmesh: nelements, three = hexas.shape for eid, element in enumerate(hexas): #print(element) elem = vtkHexahedron() elem.GetPointIds().SetId(0, element[0]) elem.GetPointIds().SetId(1, element[1]) elem.GetPointIds().SetId(2, element[2]) elem.GetPointIds().SetId(3, element[3]) elem.GetPointIds().SetId(4, element[4]) elem.GetPointIds().SetId(5, element[5]) elem.GetPointIds().SetId(6, element[6]) elem.GetPointIds().SetId(7, element[7]) self.grid.InsertNextCell(elem.GetCellType(), elem.GetPointIds()) #elem = vtkTriangle() #node_ids = elements[eid, :] #elem.GetPointIds().SetId(0, node_ids[0]) #elem.GetPointIds().SetId(1, node_ids[1]) #elem.GetPointIds().SetId(2, node_ids[2]) #elem.GetCellType() = 5 # vtkTriangle #self.grid.InsertNextCell(5, elem.GetPointIds()) elif is_surface_blockmesh: nelements, four = quads.shape for eid, element in enumerate(quads): elem = vtkQuad() elem.GetPointIds().SetId(0, element[0]) elem.GetPointIds().SetId(1, element[1]) elem.GetPointIds().SetId(2, element[2]) elem.GetPointIds().SetId(3, element[3]) self.grid.InsertNextCell(elem.GetCellType(), elem.GetPointIds()) elif is_face_mesh: elems = quads nelements = quads.shape[0] nnames = len(names) normals = zeros((nelements, 3), dtype='float32') if nnames != nelements: msg = 'nnames=%s nelements=%s names.max=%s names.min=%s' % ( nnames, nelements, names.max(), names.min()) raise RuntimeError(msg) for eid, element in enumerate(elems): #print('element = %s' % element) ineg = where(element == -1)[0] nnodes = 4 if ineg: nnodes = ineg.max() #pid = 1 pid = names[eid] if nnodes == 3: # triangle! f.write('CTRIA3,%i,%i,%i,%i,%i\n' % ( eid+1, pid, element[0]+1, element[1]+1, element[2]+1)) elem = vtkTriangle() a = nodes[element[1], :] - nodes[element[0], :] b = nodes[element[2], :] - nodes[element[0], :] n = cross(a, b) normals[eid, :] = n / norm(n) elem.GetPointIds().SetId(0, element[0]) elem.GetPointIds().SetId(1, element[1]) elem.GetPointIds().SetId(2, element[2]) self.grid.InsertNextCell(elem.GetCellType(), elem.GetPointIds()) elif nnodes == 4: f.write('CQUAD4,%i,%i,%i,%i,%i,%i\n' % ( eid+1, pid, element[0]+1, element[1]+1, element[2]+1, element[3]+1)) a = nodes[element[2], :] - nodes[element[0], :] b = nodes[element[3], :] - nodes[element[1], :] n = cross(a, b) normals[eid, :] = n / norm(n) elem = vtkQuad() elem.GetPointIds().SetId(0, element[0]) elem.GetPointIds().SetId(1, element[1]) elem.GetPointIds().SetId(2, element[2]) elem.GetPointIds().SetId(3, element[3]) self.grid.InsertNextCell(elem.GetCellType(), elem.GetPointIds()) else: raise RuntimeError('nnodes=%s' % nnodes) else: msg = 'is_surface_blockmesh=%s is_face_mesh=%s; pick one' % ( is_surface_blockmesh, is_face_mesh) raise RuntimeError(msg) self.nElements = nelements self.grid.SetPoints(points) #self.grid2.SetPoints(points2) #self.grid.GetPointData().SetScalars(self.gridResult) #print(dir(self.grid) #.SetNumberOfComponents(0)) #self.grid.GetCellData().SetNumberOfTuples(1); #self.grid.GetCellData().SetScalars(self.gridResult) self.grid.Modified() #self.grid2.Modified() self.grid.Update() #self.grid2.Update() print("updated grid") # loadCart3dResults - regions/loads self.TurnTextOn() self.scalarBar.VisibilityOn() self.scalarBar.Modified() #assert loads is not None #if 'Mach' in loads: #avgMach = mean(loads['Mach']) #note = ': avg(Mach)=%g' % avgMach #else: #note = '' #self.iSubcaseNameMap = {1: ['Cart3d%s' % note, '']} self.iSubcaseNameMap = {0: ['OpenFoam BlockMeshDict', '']} cases = {} ID = 1 #print("nElements = ",nElements) f.write('ENDDATA\n') f.close() if mesh_3d == 'hex': form, cases = self._fill_openfoam_case(cases, ID, nodes, nelements, patches, names, normals, is_surface_blockmesh) elif mesh_3d == 'shell': form, cases = self._fill_openfoam_case(cases, ID, nodes, nelements, patches, names, normals, is_surface_blockmesh) elif mesh_3d == 'faces': if len(names) == nelements: is_surface_blockmesh = True form, cases = self._fill_openfoam_case(cases, ID, nodes, nelements, patches, names, normals, is_surface_blockmesh) else: raise RuntimeError(mesh_3d) if plot: self._finish_results_io2(form, cases)
aPixelGrid.InsertNextCell(aPixel.GetCellType(),aPixel.GetPointIds()) aPixelGrid.SetPoints(pixelPoints) aPixelMapper = vtk.vtkDataSetMapper() aPixelMapper.SetInputData(aPixelGrid) aPixelActor = vtk.vtkActor() aPixelActor.SetMapper(aPixelMapper) aPixelActor.AddPosition(0,0,2) aPixelActor.GetProperty().BackfaceCullingOn() # Quad quadPoints = vtk.vtkPoints() quadPoints.SetNumberOfPoints(4) quadPoints.InsertPoint(0,0,0,0) quadPoints.InsertPoint(1,1,0,0) quadPoints.InsertPoint(2,1,1,0) quadPoints.InsertPoint(3,0,1,0) aQuad = vtk.vtkQuad() aQuad.GetPointIds().SetId(0,0) aQuad.GetPointIds().SetId(1,1) aQuad.GetPointIds().SetId(2,2) aQuad.GetPointIds().SetId(3,3) aQuadGrid = vtk.vtkUnstructuredGrid() aQuadGrid.Allocate(1,1) aQuadGrid.InsertNextCell(aQuad.GetCellType(),aQuad.GetPointIds()) aQuadGrid.SetPoints(quadPoints) aQuadMapper = vtk.vtkDataSetMapper() aQuadMapper.SetInputData(aQuadGrid) aQuadActor = vtk.vtkActor() aQuadActor.SetMapper(aQuadMapper) aQuadActor.AddPosition(2,0,2) aQuadActor.GetProperty().BackfaceCullingOn() # Triangle
def loadGeometry(self, bdf_filename): model = BDF() model.readBDF(bdf_filename) nNodes = model.nNodes() nElements = model.nElements() nCAeros = model.nCAeros() #print "nNodes = ",nNodes print "nElements = ", nElements self.grid = vtk.vtkUnstructuredGrid() self.grid2 = vtk.vtkUnstructuredGrid() #self.aQuadGrid.Allocate(nElements+nNodes, 1000) if 'CONM2' in model.cardCount: nCONM2 = model.cardCount['CONM2'] else: nCONM2 = 0 self.grid.Allocate(nElements, 1000) self.grid2.Allocate(nCAeros + nCONM2, 1000) points = vtk.vtkPoints() points.SetNumberOfPoints(nNodes) nidMap = {} i = 0 #elem.SetNumberOfPoints(nNodes) for nid, node in sorted(model.nodes.iteritems()): #print "i = ",i point = node.Position() #print "point = ",point #sys.stdout.flush() #aVoxel = vtk.vtkPixel() #print "made voxel"; sys.stdout.flush() points.InsertPoint(i, *point) #print str(element) #elem = vtk.vtkVertex() #elem.GetPointIds().SetId(0, i) #self.aQuadGrid.InsertNextCell(elem.GetCellType(), elem.GetPointIds()) nidMap[nid] = i i += 1 j = 0 points2 = vtk.vtkPoints() points2.SetNumberOfPoints(nCAeros * 4 + nCONM2) for eid, element in sorted(model.caeros.iteritems()): if isinstance(element, CAERO1): cpoints = element.Points() elem = vtkQuad() elem.GetPointIds().SetId(0, j) elem.GetPointIds().SetId(1, j + 1) elem.GetPointIds().SetId(2, j + 2) elem.GetPointIds().SetId(3, j + 3) points2.InsertPoint(j, *cpoints[0]) points2.InsertPoint(j + 1, *cpoints[1]) points2.InsertPoint(j + 2, *cpoints[2]) points2.InsertPoint(j + 3, *cpoints[3]) self.grid2.InsertNextCell( elem.GetCellType(), elem.GetPointIds()) j += 4 self.mapElements(points, points2, nidMap, model, j)
def rhombic_dodecahedron(): # http://www.vtk.org/pipermail/vtkusers/2014-September/085077.html import vtk # This is a Rhombic Dodecahedron. # First, you need to store the vertex locations. vertex_locations = vtk.vtkPoints() vertex_locations.SetNumberOfPoints(14) vertex_locations.SetPoint(0, (-0.816497, -0.816497, 0.00000)) vertex_locations.SetPoint(1, (-0.816497, 0.000000, -0.57735)) vertex_locations.SetPoint(2, (-0.816497, 0.000000, 0.57735)) vertex_locations.SetPoint(3, (-0.816497, 0.816497, 0.00000)) vertex_locations.SetPoint(4, (0.000000, -0.816497, -0.57735)) vertex_locations.SetPoint(5, (0.000000, -0.816497, 0.57735)) vertex_locations.SetPoint(6, (0.000000, 0.000000, -1.15470)) vertex_locations.SetPoint(7, (0.000000, 0.000000, 1.15470)) vertex_locations.SetPoint(8, (0.000000, 0.816497, -0.57735)) vertex_locations.SetPoint(9, (0.000000, 0.816497, 0.57735)) vertex_locations.SetPoint(10, (0.816497, -0.816497, 0.00000)) vertex_locations.SetPoint(11, (0.816497, 0.000000, -0.57735)) vertex_locations.SetPoint(12, (0.816497, 0.000000, 0.57735)) vertex_locations.SetPoint(13, (0.816497, 0.816497, 0.00000)) # Next, you describe the polygons that represent the faces using the vertex # indices in the vtkPoints that stores the vertex locations. There are a #number # of ways to do this that you can find in examples on the Wiki. polygon_faces = vtk.vtkCellArray() q = vtk.vtkQuad() q.GetPointIds().SetId(0, 7) q.GetPointIds().SetId(1, 12) q.GetPointIds().SetId(2, 10) q.GetPointIds().SetId(3, 5) polygon_faces.InsertNextCell(q) q = vtk.vtkQuad() q.GetPointIds().SetId(0, 7) q.GetPointIds().SetId(1, 12) q.GetPointIds().SetId(2, 13) q.GetPointIds().SetId(3, 9) polygon_faces.InsertNextCell(q) q = vtk.vtkQuad() q.GetPointIds().SetId(0, 7) q.GetPointIds().SetId(1, 9) q.GetPointIds().SetId(2, 3) q.GetPointIds().SetId(3, 2) polygon_faces.InsertNextCell(q) q = vtk.vtkQuad() q.GetPointIds().SetId(0, 7) q.GetPointIds().SetId(1, 2) q.GetPointIds().SetId(2, 0) q.GetPointIds().SetId(3, 5) polygon_faces.InsertNextCell(q) q = vtk.vtkQuad() q.GetPointIds().SetId(0, 6) q.GetPointIds().SetId(1, 11) q.GetPointIds().SetId(2, 10) q.GetPointIds().SetId(3, 4) polygon_faces.InsertNextCell(q) q = vtk.vtkQuad() q.GetPointIds().SetId(0, 6) q.GetPointIds().SetId(1, 4) q.GetPointIds().SetId(2, 0) q.GetPointIds().SetId(3, 1) polygon_faces.InsertNextCell(q) q = vtk.vtkQuad() q.GetPointIds().SetId(0, 6) q.GetPointIds().SetId(1, 1) q.GetPointIds().SetId(2, 3) q.GetPointIds().SetId(3, 8) polygon_faces.InsertNextCell(q) q = vtk.vtkQuad() q.GetPointIds().SetId(0, 6) q.GetPointIds().SetId(1, 8) q.GetPointIds().SetId(2, 13) q.GetPointIds().SetId(3, 11) polygon_faces.InsertNextCell(q) q = vtk.vtkQuad() q.GetPointIds().SetId(0, 10) q.GetPointIds().SetId(1, 11) q.GetPointIds().SetId(2, 13) q.GetPointIds().SetId(3, 12) polygon_faces.InsertNextCell(q) q = vtk.vtkQuad() q.GetPointIds().SetId(0, 13) q.GetPointIds().SetId(1, 8) q.GetPointIds().SetId(2, 3) q.GetPointIds().SetId(3, 9) polygon_faces.InsertNextCell(q) q = vtk.vtkQuad() q.GetPointIds().SetId(0, 3) q.GetPointIds().SetId(1, 1) q.GetPointIds().SetId(2, 0) q.GetPointIds().SetId(3, 2) polygon_faces.InsertNextCell(q) q = vtk.vtkQuad() q.GetPointIds().SetId(0, 0) q.GetPointIds().SetId(1, 4) q.GetPointIds().SetId(2, 10) q.GetPointIds().SetId(3, 5) polygon_faces.InsertNextCell(q) # Next you create a vtkPolyData to store your face and vertex information #that # represents your polyhedron. pd = vtk.vtkPolyData() pd.SetPoints(vertex_locations) pd.SetPolys(polygon_faces) # If you wanted to be able to load in the saved file and select the entire # polyhedron, you would need to save it as a vtkUnstructuredGrid, and you #would # need to put the data into a vtkPolyhedron. This is a bit more involved #than # the vtkPolyData that I used above. For a more in-depth discussion, see: # http://www.vtk.org/Wiki/VTK/Polyhedron_Support # Based on the link above, I need to construct a face stream: face_stream = vtk.vtkIdList() face_stream.InsertNextId(polygon_faces.GetNumberOfCells()) vertex_list = vtk.vtkIdList() polygon_faces.InitTraversal() while polygon_faces.GetNextCell(vertex_list) == 1: face_stream.InsertNextId(vertex_list.GetNumberOfIds()) for j in range(vertex_list.GetNumberOfIds()): face_stream.InsertNextId(vertex_list.GetId(j)) ug = vtk.vtkUnstructuredGrid() ug.SetPoints(vertex_locations) ug.InsertNextCell(vtk.VTK_POLYHEDRON, face_stream) #--------------# # output stuff # #--------------# writer = vtk.vtkUnstructuredGridWriter() writer.SetFileName("rhombic_dodecahedron.vtk") #writer.SetInputData(ug) writer.SetInput(ug) writer.Write() #---------------------# # visualization stuff # #---------------------# # mapper = vtk.vtkPolyDataMapper() # mapper.SetInputData(pd) mapper = vtk.vtkDataSetMapper() mapper.SetInput(ug) actor = vtk.vtkActor() actor.SetMapper(mapper) ren = vtk.vtkRenderer() ren.AddActor(actor) renw = vtk.vtkRenderWindow() renw.AddRenderer(ren) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renw) ren.ResetCamera() renw.Render() iren.Start()
def mapElements(self, points, points2, nidMap, model, j): for eid, element in sorted(model.elements.iteritems()): if isinstance(element, CTRIA3): #print "ctria3" elem = vtkTriangle() nodeIDs = element.nodeIDs() elem.GetPointIds().SetId(0, nidMap[nodeIDs[0]]) elem.GetPointIds().SetId(1, nidMap[nodeIDs[1]]) elem.GetPointIds().SetId(2, nidMap[nodeIDs[2]]) self.grid.InsertNextCell( elem.GetCellType(), elem.GetPointIds()) elif isinstance(element, CTRIA6): nodeIDs = element.nodeIDs() if None not in nodeIDs: elem = vtkQuadraticTriangle() elem.GetPointIds().SetId(3, nidMap[nodeIDs[3]]) elem.GetPointIds().SetId(4, nidMap[nodeIDs[4]]) elem.GetPointIds().SetId(5, nidMap[nodeIDs[5]]) else: elem = vtkTriangle() elem.GetPointIds().SetId(0, nidMap[nodeIDs[0]]) elem.GetPointIds().SetId(1, nidMap[nodeIDs[1]]) elem.GetPointIds().SetId(2, nidMap[nodeIDs[2]]) self.grid.InsertNextCell( elem.GetCellType(), elem.GetPointIds()) elif isinstance(element, CQUAD4): nodeIDs = element.nodeIDs() elem = vtkQuad() elem.GetPointIds().SetId(0, nidMap[nodeIDs[0]]) elem.GetPointIds().SetId(1, nidMap[nodeIDs[1]]) elem.GetPointIds().SetId(2, nidMap[nodeIDs[2]]) elem.GetPointIds().SetId(3, nidMap[nodeIDs[3]]) self.grid.InsertNextCell( elem.GetCellType(), elem.GetPointIds()) elif isinstance(element, CQUAD8): nodeIDs = element.nodeIDs() if None not in nodeIDs: elem = vtkQuadraticQuad() elem.GetPointIds().SetId(4, nidMap[nodeIDs[4]]) elem.GetPointIds().SetId(5, nidMap[nodeIDs[5]]) elem.GetPointIds().SetId(6, nidMap[nodeIDs[6]]) elem.GetPointIds().SetId(7, nidMap[nodeIDs[7]]) else: elem = vtkQuad() elem.GetPointIds().SetId(0, nidMap[nodeIDs[0]]) elem.GetPointIds().SetId(1, nidMap[nodeIDs[1]]) elem.GetPointIds().SetId(2, nidMap[nodeIDs[2]]) elem.GetPointIds().SetId(3, nidMap[nodeIDs[3]]) self.grid.InsertNextCell( elem.GetCellType(), elem.GetPointIds()) elif isinstance(element, CTETRA4): elem = vtkTetra() nodeIDs = element.nodeIDs() elem.GetPointIds().SetId(0, nidMap[nodeIDs[0]]) elem.GetPointIds().SetId(1, nidMap[nodeIDs[1]]) elem.GetPointIds().SetId(2, nidMap[nodeIDs[2]]) elem.GetPointIds().SetId(3, nidMap[nodeIDs[3]]) self.grid.InsertNextCell( elem.GetCellType(), elem.GetPointIds()) elif isinstance(element, CTETRA10): nodeIDs = element.nodeIDs() if None not in nodeIDs: elem = vtkQuadraticTetra() elem.GetPointIds().SetId(4, nidMap[nodeIDs[4]]) elem.GetPointIds().SetId(5, nidMap[nodeIDs[5]]) elem.GetPointIds().SetId(6, nidMap[nodeIDs[6]]) elem.GetPointIds().SetId(7, nidMap[nodeIDs[7]]) elem.GetPointIds().SetId(8, nidMap[nodeIDs[8]]) elem.GetPointIds().SetId(9, nidMap[nodeIDs[9]]) else: elem = vtkTetra() elem.GetPointIds().SetId(0, nidMap[nodeIDs[0]]) elem.GetPointIds().SetId(1, nidMap[nodeIDs[1]]) elem.GetPointIds().SetId(2, nidMap[nodeIDs[2]]) elem.GetPointIds().SetId(3, nidMap[nodeIDs[3]]) self.grid.InsertNextCell( elem.GetCellType(), elem.GetPointIds()) elif isinstance(element, CPENTA6): elem = vtkWedge() nodeIDs = element.nodeIDs() elem.GetPointIds().SetId(0, nidMap[nodeIDs[0]]) elem.GetPointIds().SetId(1, nidMap[nodeIDs[1]]) elem.GetPointIds().SetId(2, nidMap[nodeIDs[2]]) elem.GetPointIds().SetId(3, nidMap[nodeIDs[3]]) elem.GetPointIds().SetId(4, nidMap[nodeIDs[4]]) elem.GetPointIds().SetId(5, nidMap[nodeIDs[5]]) self.grid.InsertNextCell( elem.GetCellType(), elem.GetPointIds()) elif isinstance(element, CPENTA15): nodeIDs = element.nodeIDs() if None not in nodeIDs: elem = vtkQuadraticWedge() elem.GetPointIds().SetId(6, nidMap[nodeIDs[6]]) elem.GetPointIds().SetId(7, nidMap[nodeIDs[7]]) elem.GetPointIds().SetId(8, nidMap[nodeIDs[8]]) elem.GetPointIds().SetId(9, nidMap[nodeIDs[9]]) elem.GetPointIds().SetId(10, nidMap[nodeIDs[10]]) elem.GetPointIds().SetId(11, nidMap[nodeIDs[11]]) elem.GetPointIds().SetId(12, nidMap[nodeIDs[12]]) elem.GetPointIds().SetId(13, nidMap[nodeIDs[13]]) elem.GetPointIds().SetId(14, nidMap[nodeIDs[14]]) else: elem = vtkWedge() elem.GetPointIds().SetId(0, nidMap[nodeIDs[0]]) elem.GetPointIds().SetId(1, nidMap[nodeIDs[1]]) elem.GetPointIds().SetId(2, nidMap[nodeIDs[2]]) elem.GetPointIds().SetId(3, nidMap[nodeIDs[3]]) elem.GetPointIds().SetId(4, nidMap[nodeIDs[4]]) elem.GetPointIds().SetId(5, nidMap[nodeIDs[5]]) self.grid.InsertNextCell( elem.GetCellType(), elem.GetPointIds()) elif isinstance(element, CHEXA8): nodeIDs = element.nodeIDs() elem = vtkHexahedron() elem.GetPointIds().SetId(0, nidMap[nodeIDs[0]]) elem.GetPointIds().SetId(1, nidMap[nodeIDs[1]]) elem.GetPointIds().SetId(2, nidMap[nodeIDs[2]]) elem.GetPointIds().SetId(3, nidMap[nodeIDs[3]]) elem.GetPointIds().SetId(4, nidMap[nodeIDs[4]]) elem.GetPointIds().SetId(5, nidMap[nodeIDs[5]]) elem.GetPointIds().SetId(6, nidMap[nodeIDs[6]]) elem.GetPointIds().SetId(7, nidMap[nodeIDs[7]]) self.grid.InsertNextCell( elem.GetCellType(), elem.GetPointIds()) elif isinstance(element, CHEXA20): nodeIDs = element.nodeIDs() #print "nodeIDs = ",nodeIDs if None not in nodeIDs: elem = vtkQuadraticHexahedron() elem.GetPointIds().SetId(8, nidMap[nodeIDs[8]]) elem.GetPointIds().SetId(9, nidMap[nodeIDs[9]]) elem.GetPointIds().SetId(10, nidMap[nodeIDs[10]]) elem.GetPointIds().SetId(11, nidMap[nodeIDs[11]]) elem.GetPointIds().SetId(12, nidMap[nodeIDs[12]]) elem.GetPointIds().SetId(13, nidMap[nodeIDs[13]]) elem.GetPointIds().SetId(14, nidMap[nodeIDs[14]]) elem.GetPointIds().SetId(15, nidMap[nodeIDs[15]]) elem.GetPointIds().SetId(16, nidMap[nodeIDs[16]]) elem.GetPointIds().SetId(17, nidMap[nodeIDs[17]]) elem.GetPointIds().SetId(18, nidMap[nodeIDs[18]]) elem.GetPointIds().SetId(19, nidMap[nodeIDs[19]]) else: elem = vtkHexahedron() elem.GetPointIds().SetId(0, nidMap[nodeIDs[0]]) elem.GetPointIds().SetId(1, nidMap[nodeIDs[1]]) elem.GetPointIds().SetId(2, nidMap[nodeIDs[2]]) elem.GetPointIds().SetId(3, nidMap[nodeIDs[3]]) elem.GetPointIds().SetId(4, nidMap[nodeIDs[4]]) elem.GetPointIds().SetId(5, nidMap[nodeIDs[5]]) elem.GetPointIds().SetId(6, nidMap[nodeIDs[6]]) elem.GetPointIds().SetId(7, nidMap[nodeIDs[7]]) self.grid.InsertNextCell( elem.GetCellType(), elem.GetPointIds()) elif isinstance(element, LineElement) or isinstance(element, SpringElement): elem = vtk.vtkLine() nodeIDs = element.nodeIDs() elem.GetPointIds().SetId(0, nidMap[nodeIDs[0]]) elem.GetPointIds().SetId(1, nidMap[nodeIDs[1]]) self.grid.InsertNextCell( elem.GetCellType(), elem.GetPointIds()) ### elif isinstance(element, CONM2): # not perfectly located nid = element.Nid() c = element.Centroid() elem = vtk.vtkVertex() #elem = vtk.vtkSphere() #elem.SetRadius(1.0) #print str(element) points2.InsertPoint(j, *c) elem.GetPointIds().SetId(0, j) #elem.SetCenter(points.GetPoint(nidMap[nid])) self.grid2.InsertNextCell( elem.GetCellType(), elem.GetPointIds()) j += 1 else: print "skipping %s" % (element.type) ### self.grid.SetPoints(points) self.grid2.SetPoints(points2) self.grid.Update() self.grid2.Update()
def load_panair_geometry(self, panair_filename, dirname, name='main', plot=True): self.nid_map = {} #key = self.case_keys[self.icase] #case = self.result_cases[key] skip_reading = self._remove_old_geometry(panair_filename) if skip_reading: return model = PanairGrid(log=self.log, debug=self.debug) self.model_type = model.model_type model.read_panair(panair_filename) nodes, elements, regions, kt, cp_norm = model.get_points_elements_regions() #for nid, node in enumerate(nodes): #print "node[%s] = %s" % (nid, str(node)) self.nNodes = len(nodes) self.nElements = len(elements) #print("nNodes = ",self.nNodes) #print("nElements = ", self.nElements) self.grid.Allocate(self.nElements, 1000) #self.gridResult.SetNumberOfComponents(self.nElements) points = vtk.vtkPoints() points.SetNumberOfPoints(self.nNodes) #self.gridResult.Allocate(self.nNodes, 1000) #vectorReselt.SetNumberOfComponents(3) #elem.SetNumberOfPoints(nNodes) if 0: fraction = 1. / nnodes # so you can color the nodes by ID for nid, node in sorted(iteritems(nodes)): points.InsertPoint(nid - 1, *point) self.gridResult.InsertNextValue(nid * fraction) #print str(element) #elem = vtk.vtkVertex() #elem.GetPointIds().SetId(0, i) #self.aQuadGrid.InsertNextCell(elem.GetCellType(), elem.GetPointIds()) #vectorResult.InsertTuple3(0, 0.0, 0.0, 1.0) assert len(nodes) > 0 mmax = amax(nodes, axis=0) mmin = amin(nodes, axis=0) dim_max = (mmax - mmin).max() self.create_global_axes(dim_max) for nid, node in enumerate(nodes): points.InsertPoint(nid, *node) assert len(elements) > 0 elem = vtkQuad() quad_type = elem.GetCellType() for eid, element in enumerate(elements): (p1, p2, p3, p4) = element elem = vtkQuad() elem.GetPointIds().SetId(0, p1) elem.GetPointIds().SetId(1, p2) elem.GetPointIds().SetId(2, p3) elem.GetPointIds().SetId(3, p4) self.grid.InsertNextCell(quad_type, elem.GetPointIds()) self.grid.SetPoints(points) #self.grid.GetPointData().SetScalars(self.gridResult) #print dir(self.grid) #.SetNumberOfComponents(0) #self.grid.GetCellData().SetNumberOfTuples(1); #self.grid.GetCellData().SetScalars(self.gridResult) self.grid.Modified() if hasattr(self.grid, 'Update'): self.grid.Update() # loadPanairResults - regions/loads self. turn_text_on() if plot: self.scalarBar.VisibilityOn() self.scalarBar.Modified() self.iSubcaseNameMap = {1: ['Panair', '']} cases = {} ID = 1 #print "nElements = ", nElements loads = [] form, cases = self._fill_panair_geometry_case( cases, ID, nodes, elements, regions, kt, cp_norm, loads) #if plot: self._finish_results_io2(form, cases)
def load_abaqus_geometry(self, abaqus_filename, name='main', plot=True): """loads abaqus input files into the gui""" model_name = name skip_reading = self.gui._remove_old_geometry(abaqus_filename) if skip_reading: return self.gui.eid_maps[name] = {} self.gui.nid_maps[name] = {} model = Abaqus(log=self.gui.log, debug=False) self.gui.model_type = 'abaqus' #self.model_type = model.model_type model.read_abaqus_inp(abaqus_filename) n_r2d2 = 0 n_cpe3 = 0 n_cpe4 = 0 n_cpe4r = 0 n_coh2d4 = 0 n_c3d10h = 0 n_cohax4 = 0 n_cax3 = 0 n_cax4r = 0 nnodes = 0 nelements = 0 all_nodes = [] for unused_part_name, part in model.parts.items(): unused_nids = part.nids - 1 nodes = part.nodes nnodes += nodes.shape[0] if part.r2d2 is not None: n_r2d2 += part.r2d2.shape[0] if part.cpe3 is not None: n_cpe3 += part.cpe3.shape[0] if part.cpe4 is not None: n_cpe4 += part.cpe4.shape[0] if part.cpe4r is not None: n_cpe4r += part.cpe4r.shape[0] if part.coh2d4 is not None: n_coh2d4 += part.coh2d4.shape[0] if part.cohax4 is not None: n_cohax4 += part.cohax4.shape[0] if part.cax3 is not None: n_cax3 += part.cax3.shape[0] if part.cax4r is not None: n_cax4r += part.cax4r.shape[0] if part.c3d10h is not None: n_c3d10h += part.c3d10h.shape[0] all_nodes.append(nodes) nelements += (n_r2d2 + n_cpe3 + n_cpe4 + n_cpe4r + n_coh2d4 + n_c3d10h + n_cohax4 + n_cax3 + n_cax4r) assert nelements > 0, nelements #nodes = model.nodes #elements = model.elements self.gui.nnodes = nnodes self.gui.nelements = nelements grid = self.gui.grid grid.Allocate(self.gui.nelements, 1000) points = vtk.vtkPoints() points.SetNumberOfPoints(self.gui.nnodes) self.gui.nid_map = {} assert nodes is not None nnodes = nodes.shape[0] if len(all_nodes) == 1: nodes = all_nodes[0] else: nodes = np.vstack(all_nodes) mmax = np.amax(nodes, axis=0) mmin = np.amin(nodes, axis=0) dim_max = (mmax - mmin).max() self.gui.create_global_axes(dim_max) data_type = vtk.VTK_FLOAT points_array = numpy_to_vtk(num_array=nodes, deep=True, array_type=data_type) points.SetData(points_array) nid_offset = -1 for unused_part_name, part in model.parts.items(): nnodesi = part.nodes.shape[0] n_r2d2 = 0 n_cpe3 = 0 n_cpe4 = 0 n_cpe4r = 0 n_coh2d4 = 0 n_c3d10h = 0 n_cohax4 = 0 n_cax3 = 0 n_cax4r = 0 if part.r2d2 is not None: n_r2d2 += part.r2d2.shape[0] if part.cpe3 is not None: n_cpe3 += part.cpe3.shape[0] if part.cpe4 is not None: n_cpe4 += part.cpe4.shape[0] if part.cpe4r is not None: n_cpe4r += part.cpe4r.shape[0] if part.coh2d4 is not None: n_coh2d4 += part.coh2d4.shape[0] if part.cohax4 is not None: n_cohax4 += part.cohax4.shape[0] if part.cax3 is not None: n_cax3 += part.cax3.shape[0] if part.cax4r is not None: n_cax4r += part.cax4r.shape[0] # solids if part.c3d10h is not None: n_c3d10h += part.c3d10h.shape[0] if n_r2d2: eids = part.r2d2[:, 0] node_ids = part.r2d2[:, 1:] + nid_offset for unused_eid, node_ids in zip(eids, node_ids): elem = vtkLine() elem.GetPointIds().SetId(0, node_ids[0]) elem.GetPointIds().SetId(1, node_ids[1]) grid.InsertNextCell(elem.GetCellType(), elem.GetPointIds()) if n_cpe3: eids = part.cpe3[:, 0] node_ids = part.cpe3[:, 1:] + nid_offset for unused_eid, node_ids in zip(eids, node_ids): elem = vtkTriangle() elem.GetPointIds().SetId(0, node_ids[0]) elem.GetPointIds().SetId(1, node_ids[1]) elem.GetPointIds().SetId(2, node_ids[2]) grid.InsertNextCell(5, elem.GetPointIds()) if n_cpe4: eids = part.cpe4[:, 0] node_ids = part.cpe4[:, 1:] + nid_offset for unused_eid, node_ids in zip(eids, node_ids): elem = vtkQuad() elem.GetPointIds().SetId(0, node_ids[0]) elem.GetPointIds().SetId(1, node_ids[1]) elem.GetPointIds().SetId(2, node_ids[2]) elem.GetPointIds().SetId(3, node_ids[3]) grid.InsertNextCell(elem.GetCellType(), elem.GetPointIds()) if n_cpe4r: eids = part.cpe4r[:, 0] node_ids = part.cpe4r[:, 1:] + nid_offset for unused_eid, node_ids in zip(eids, node_ids): elem = vtkQuad() elem.GetPointIds().SetId(0, node_ids[0]) elem.GetPointIds().SetId(1, node_ids[1]) elem.GetPointIds().SetId(2, node_ids[2]) elem.GetPointIds().SetId(3, node_ids[3]) grid.InsertNextCell(elem.GetCellType(), elem.GetPointIds()) if n_coh2d4: eids = part.coh2d4[:, 0] node_ids = part.coh2d4[:, 1:] + nid_offset for unused_eid, node_ids in zip(eids, node_ids): elem = vtkQuad() elem.GetPointIds().SetId(0, node_ids[0]) elem.GetPointIds().SetId(1, node_ids[1]) elem.GetPointIds().SetId(2, node_ids[2]) elem.GetPointIds().SetId(3, node_ids[3]) grid.InsertNextCell(elem.GetCellType(), elem.GetPointIds()) if n_cohax4: eids = part.cohax4[:, 0] node_ids = part.cohax4[:, 1:] + nid_offset for unused_eid, node_ids in zip(eids, node_ids): elem = vtkQuad() elem.GetPointIds().SetId(0, node_ids[0]) elem.GetPointIds().SetId(1, node_ids[1]) elem.GetPointIds().SetId(2, node_ids[2]) elem.GetPointIds().SetId(3, node_ids[3]) grid.InsertNextCell(elem.GetCellType(), elem.GetPointIds()) if n_cax3: eids = part.cax3[:, 0] node_ids = part.cax3[:, 1:] + nid_offset for unused_eid, node_ids in zip(eids, node_ids): elem = vtkTriangle() elem.GetPointIds().SetId(0, node_ids[0]) elem.GetPointIds().SetId(1, node_ids[1]) elem.GetPointIds().SetId(2, node_ids[2]) grid.InsertNextCell(5, elem.GetPointIds()) if n_cax4r: eids = part.cax4r[:, 0] node_ids = part.cax4r[:, 1:] + nid_offset for unused_eid, node_ids in zip(eids, node_ids): elem = vtkQuad() elem.GetPointIds().SetId(0, node_ids[0]) elem.GetPointIds().SetId(1, node_ids[1]) elem.GetPointIds().SetId(2, node_ids[2]) elem.GetPointIds().SetId(3, node_ids[3]) grid.InsertNextCell(elem.GetCellType(), elem.GetPointIds()) # solids if n_c3d10h: eids = part.c3d10h[:, 0] node_ids = part.c3d10h[:, 1:] + nid_offset for unused_eid, node_ids in zip(eids, node_ids): #for unused_eid, node_ids in part.c3d10h: elem = vtkTetra() elem.GetPointIds().SetId(0, node_ids[0]) elem.GetPointIds().SetId(1, node_ids[1]) elem.GetPointIds().SetId(2, node_ids[2]) elem.GetPointIds().SetId(3, node_ids[3]) grid.InsertNextCell(elem.GetCellType(), elem.GetPointIds()) nid_offset += nnodesi grid.SetPoints(points) grid.Modified() # loadCart3dResults - regions/loads self.gui.scalar_bar_actor.VisibilityOn() self.gui.scalar_bar_actor.Modified() note = '' self.gui.isubcase_name_map = {1: ['Abaqus%s' % note, '']} #form = [] cases = OrderedDict() ID = 1 form, cases, unused_icase, node_ids, element_ids = self._fill_abaqus_case( cases, ID, nodes, nelements, model) #self._fill_cart3d_results(cases, form, icase, ID, model) self.gui.node_ids = node_ids self.gui.element_ids = element_ids self.gui._finish_results_io2(model_name, form, cases)