def __init__(self, pos, radius, rgb=[0.62, 0, 0.77]): self.source = vtk.vtkCubeSource() self.mapper = vtk.vtkPolyDataMapper() # length of sides self.source.SetXLength(radius) self.source.SetYLength(radius) self.source.SetZLength(radius) # centre self.source.SetCenter(pos) # edges filter edges = vtk.vtkExtractEdges() edges.SetInputConnection(self.source.GetOutputPort()) # tube filter tubes = vtk.vtkTubeFilter() tubes.SetInputConnection(edges.GetOutputPort()) tubes.SetRadius(0.15) tubes.SetNumberOfSides(5) tubes.UseDefaultNormalOn() tubes.SetDefaultNormal(.577, .577, .577) # mapper self.mapper.SetInputConnection(tubes.GetOutputPort()) # actor self.SetMapper(self.mapper) self.GetProperty().SetColor(rgb)
def make_sphere(): global renderer # --------------------------------------------------------------- # The following code is identical to render_demo.py... # --------------------------------------------------------------- # create a sphere sphere_src = vtk.vtkSphereSource() sphere_src.SetRadius(1.0) sphere_src.SetCenter(0.0, 0.0, 0.0) sphere_src.SetThetaResolution(20) sphere_src.SetPhiResolution(20) # extract the edges edge_extractor = vtk.vtkExtractEdges() edge_extractor.SetInputConnection(sphere_src.GetOutputPort()) # map sphere and edges separately sphere_mapper = vtk.vtkPolyDataMapper() sphere_mapper.SetInputConnection(sphere_src.GetOutputPort()) edge_mapper = vtk.vtkPolyDataMapper() edge_mapper.SetInputConnection(edge_extractor.GetOutputPort()) # define different rendering styles for sphere and edges sphere_actor = vtk.vtkActor() sphere_actor.SetMapper(sphere_mapper) sphere_actor.GetProperty().SetColor(1, 0.5, 0) edge_actor = vtk.vtkActor() edge_actor.SetMapper(edge_mapper) edge_actor.GetProperty().SetColor(0, 0.5, 0) edge_actor.GetProperty().SetLineWidth(3) # add resulting primitives to renderer renderer.AddActor(sphere_actor) renderer.AddActor(edge_actor)
def __init__(self, module_manager): SimpleVTKClassModuleBase.__init__( self, module_manager, vtk.vtkExtractEdges(), 'Processing.', ('vtkDataSet',), ('vtkPolyData',), replaceDoc=True, inputFunctions=None, outputFunctions=None)
def render(self, pointsData, scalarsArray, radiusArray, nspecies, colouringOptions, atomScaleFactor, lut): """ Render the given antisites (wire frame). """ self._logger.debug("Rendering antisites: colour by '%s'", colouringOptions.colourBy) # points points = vtk.vtkPoints() points.SetData(pointsData.getVTK()) # poly data polydata = vtk.vtkPolyData() polydata.SetPoints(points) polydata.GetPointData().AddArray(scalarsArray.getVTK()) polydata.GetPointData().SetScalars(radiusArray.getVTK()) # source cubeSource = vtk.vtkCubeSource() edges = vtk.vtkExtractEdges() edges.SetInputConnection(cubeSource.GetOutputPort()) glyphSource = vtk.vtkTubeFilter() glyphSource.SetInputConnection(edges.GetOutputPort()) glyphSource.SetRadius(0.05) glyphSource.SetVaryRadius(0) glyphSource.SetNumberOfSides(5) glyphSource.UseDefaultNormalOn() glyphSource.SetDefaultNormal(0.577, 0.577, 0.577) # glyph glyph = vtk.vtkGlyph3D() if vtk.vtkVersion.GetVTKMajorVersion() <= 5: glyph.SetSource(glyphSource.GetOutput()) glyph.SetInput(polydata) else: glyph.SetSourceConnection(glyphSource.GetOutputPort()) glyph.SetInputData(polydata) glyph.SetScaleFactor(atomScaleFactor * 2.0) glyph.SetScaleModeToScaleByScalar() glyph.ClampingOff() # mapper mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(glyph.GetOutputPort()) mapper.SetLookupTable(lut) mapper.SetScalarModeToUsePointFieldData() mapper.SelectColorArray("colours") utils.setMapperScalarRange(mapper, colouringOptions, nspecies) # actor actor = vtk.vtkActor() actor.SetMapper(mapper) # store attributes self._actor = utils.ActorObject(actor) self._data["Points"] = pointsData self._data["Scalars"] = scalarsArray self._data["Radius"] = radiusArray self._data["LUT"] = lut self._data["Scale factor"] = atomScaleFactor
def __init__(self, **kwargs): self.hull = vtk.vtkHull() self.poly_data = vtk.vtkPolyData() self.extractor = vtk.vtkExtractEdges() self.extractor.SetInput(self.poly_data) self.mapper = vtk.vtkPolyDataMapper() self.mapper.SetInputConnection(self.extractor.GetOutputPort()) self.actor = vtk.vtkActor() self.actor.SetMapper(self.mapper) self._process_kwargs(**kwargs)
def get_edges(self): edges = vtk.vtkExtractEdges() edges.SetInput(self.grid) self.edgeMapper.SetInput(edges.GetOutput()) self.edgeActor.SetMapper(self.edgeMapper) self.edgeActor.GetProperty().SetColor(0, 0, 0) prop = self.edgeActor.GetProperty() self.edgeActor.SetVisibility(self.is_edges) self.rend.AddActor(self.edgeActor)
def compute_info_mesh(mesh): vertices= mesh.GetNumberOfPoints() triangles= mesh.GetNumberOfCells() extractEdges = vtk.vtkExtractEdges() extractEdges.SetInputData(mesh) extractEdges.Update() lines=extractEdges.GetOutput() edges=lines.GetNumberOfCells() print "triangles: ",triangles print "vertices: ",vertices print "edges: ",edges return vertices,triangles
def vtkpoints(points, color=None, radius=None): # Create a polydata with the points we just created. profile = vtk.vtkPolyData() profile.SetPoints(points) # Perform a 2D Delaunay triangulation on them. delny = vtk.vtkDelaunay2D() delny.SetInput(profile) delny.SetTolerance(0.001) mapMesh = vtk.vtkPolyDataMapper() mapMesh.SetInputConnection(delny.GetOutputPort()) meshActor = vtk.vtkActor() meshActor.SetMapper(mapMesh) meshActor.GetProperty().SetColor(0.1, 0.2, 0.1) # We will now create a nice looking mesh by wrapping the edges in tubes, # and putting fat spheres at the points. extract = vtk.vtkExtractEdges() extract.SetInputConnection(delny.GetOutputPort()) ball = vtk.vtkSphereSource() if radius == None: rad = 0.002 else: rad = radius print rad ball.SetRadius(rad) ball.SetThetaResolution(50) ball.SetPhiResolution(5) balls = vtk.vtkGlyph3D() balls.SetInputConnection(delny.GetOutputPort()) balls.SetSourceConnection(ball.GetOutputPort()) mapBalls = vtk.vtkPolyDataMapper() mapBalls.SetInputConnection(balls.GetOutputPort()) ballActor = vtk.vtkActor() ballActor.SetMapper(mapBalls) if color == None: ballcolor = red else: ballcolor = color print "setting ball color to...", ballcolor ballActor.GetProperty().SetColor(ballcolor) ballActor.GetProperty().SetSpecularColor(0, 0, 0) ballActor.GetProperty().SetSpecular(0.3) ballActor.GetProperty().SetSpecularPower(500) ballActor.GetProperty().SetAmbient(0.2) ballActor.GetProperty().SetDiffuse(0.8) return ballActor, profile
def CreateWirePolyData(self): ''' @rtype: None ''' if self.getWirePolyData(): return if not self.GetPolyData(): return extractor = vtk.vtkExtractEdges() extractor.SetInput(self.GetPolyData()) extractor.Update() self.setWirePolyData(extractor.GetOutput()) # del extractor self.Modified()
def unstructedGridToWireframe(grid,bkgdColor=[255,255,255],color=[0,0,0],renderer=None): """Extracts mesh as wireframe plot from unstructured grid and adds it to renderer. .. note:: Will create new renderer if none is given. Keyword Args: fnVTK (str): Path to input vtk file. bkgdColor (list): Background color in RGB values. color (list): Color of mesh in RGB values. renderer (vtk.vtkRenderer): Some renderer. Returns: vtk.vtkRenderer: Renderer object. """ #Extract Edges edges=vtk.vtkExtractEdges() edges.SetInput(grid) #Make edges into tubes tubes = vtk.vtkTubeFilter() tubes.SetInput(edges.GetOutput()) tubes.SetRadius(0.5) tubes.SetNumberOfSides(3) #Genereate wireframe mapper wireFrameMapper=vtk.vtkPolyDataMapper() wireFrameMapper.SetInput(tubes.GetOutput()) wireFrameMapper.SetScalarVisibility(0) #Make Actor wireFrameActor=vtk.vtkActor() wireFrameActor.SetMapper(wireFrameMapper) wireFrameActor.GetProperty().SetColor(color[0],color[1],color[2]) wireFrameActor.SetPickable(0) #Create the Renderer if renderer==None: renderer = vtk.vtkRenderer() # Add to renderer renderer.AddActor(wireFrameActor) renderer.SetBackground(bkgdColor[0], bkgdColor[1], bkgdColor[2]) return renderer
def taubin_smooth(poly, l, m, steps): edgesfilter = vtk.vtkExtractEdges() edgesfilter.SetInput(poly) edgesfilter.Update() edges = edgesfilter.GetOutput() new_poly = vtk.vtkPolyData() new_poly.DeepCopy(poly) print edges.GetNumberOfPoints() print poly.GetNumberOfPoints() points = new_poly.GetPoints() for s in xrange(steps): D = {} for i in xrange(edges.GetNumberOfPoints()): D[i] = calculate_d(edges, new_poly, i) for i in xrange(poly.GetNumberOfPoints()): p = np.array(points.GetPoint(i)) pl = p + l*D[i] nx, ny, nz = pl points.SetPoint(i, nx, ny, nz) D = {} for i in xrange(edges.GetNumberOfPoints()): D[i] = calculate_d(edges, new_poly, i) for i in xrange(poly.GetNumberOfPoints()): p = np.array(points.GetPoint(i)) pl = p + m*D[i] nx, ny, nz = pl points.SetPoint(i, nx, ny, nz) #D = {} #for i in xrange(edges.GetNumberOfPoints()): #D[i] = calculate_d(edges, i) #for i in xrange(poly.GetNumberOfPoints()): #x, y, z = points.GetPoint(i) #nx = x + m*D[i][0] #ny = y + m*D[i][1] #nz = z + m*D[i][2] #points.SetPoint(i, nx, ny, nz) #new_poly.SetPoints(points) return new_poly
def getEdges(self): edges = vtk.vtkExtractEdges() edges.SetInput(self.grid) self.edgeMapper = vtk.vtkPolyDataMapper() self.edgeMapper.SetInput(edges.GetOutput()) #self.edgeMapper.EdgeVisibilityOff() self.edgeActor = vtk.vtkActor() self.edgeActor.SetMapper(self.edgeMapper) self.edgeActor.GetProperty().SetColor(0, 0, 0) prop = self.edgeActor.GetProperty() #prop.SetLineWidth(0.0) if self.isEdges: prop.EdgeVisibilityOn() else: prop.EdgeVisibilityOff() self.rend.AddActor(self.edgeActor) vtk.vtkPolyDataMapper().SetResolveCoincidentTopologyToPolygonOffset() print "visible = ", prop.GetEdgeVisibility()
def Edges(cm, cl=khaki): Edges = vtk.vtkExtractEdges() Edges.SetInputConnection(cm.GetOutputPort()) Tubes = vtk.vtkTubeFilter() Tubes.SetInputConnection(Edges.GetOutputPort()) Tubes.SetRadius(.01) Tubes.SetNumberOfSides(6) Tubes.UseDefaultNormalOn() Tubes.SetDefaultNormal(.577, .577, .577) # Create the mapper and actor to display the cube edges. TubeMapper = vtk.vtkPolyDataMapper() TubeMapper.SetInputConnection(Tubes.GetOutputPort()) CubeEdges = vtk.vtkActor() CubeEdges.SetMapper(TubeMapper) CubeEdges.GetProperty().SetDiffuseColor(cl) CubeEdges.GetProperty().SetSpecular(.4) CubeEdges.GetProperty().SetSpecularPower(10) return CubeEdges
def getEdges(self): edges = vtk.vtkExtractEdges() edges.SetInput(self.grid) self.edgeMapper = vtk.vtkPolyDataMapper() self.edgeMapper.SetInput(edges.GetOutput()) #edges.GetOutput().ReleaseDataFlagOn() #self.edgeMapper.EdgeVisibilityOff() self.edgeActor = vtk.vtkActor() self.edgeActor.SetMapper(self.edgeMapper) self.edgeActor.GetProperty().SetColor(0, 0, 0) prop = self.edgeActor.GetProperty() #prop.SetLineWidth(0.0) if self.isEdges: prop.EdgeVisibilityOn() else: prop.EdgeVisibilityOff() self.rend.AddActor(self.edgeActor) print("visible = %s" % (prop.GetEdgeVisibility()))
def make_cubeActor (lattice, radius=0.1): CubeModel = vtk.vtkCubeSource() CubeModel.SetXLength(lattice[0]) CubeModel.SetYLength(lattice[1]) CubeModel.SetZLength(lattice[2]) CubeModel.SetCenter(.5*lattice[0], .5*lattice[1], .5*lattice[2]) Edges = vtk.vtkExtractEdges() Edges.SetInput(CubeModel.GetOutput()) Tubes = vtk.vtkTubeFilter() Tubes.SetInput(Edges.GetOutput()) Tubes.SetRadius(radius) Tubes.SetNumberOfSides(6) Tubes.UseDefaultNormalOn() Tubes.SetDefaultNormal(.577, .577, .577) # Create the mapper and actor to display the cube edges. TubeMapper = vtk.vtkPolyDataMapper() TubeMapper.SetInput(Tubes.GetOutput()) CubeEdges = vtk.vtkActor() CubeEdges.SetMapper(TubeMapper) CubeEdges.GetProperty().SetDiffuseColor(khaki) CubeEdges.GetProperty().SetSpecular(.4) CubeEdges.GetProperty().SetSpecularPower(10) #ren.AddActor(CubeEdges) return(CubeEdges)
def get_vtk_edges(vtkdata): """ Get mesh edges. Parameters ---------- vtkdata : VTK object Mesh, scalar, vector and tensor data. Returns ------- edges : VTK object Mesh, scalar, vector and tensor data. """ edges = vtk.vtkExtractEdges() if vtk_version < 6: edges.SetInput(vtkdata) else: edges.SetInputData(vtkdata) edges.Update() return edges.GetOutput()
def GetActor(self): planeCnt = 3 planeSources = [] for createSources in range(planeCnt): planeSources.append(vtk.vtkPlaneSource()) self.planeSources = planeSources endPts = ((0, 0, 0), (1, 0, 0), (0, 0, 1), (0, 1, 0), (1, 1, 0), (0, 0, 0), (0, 1, 0), (0, 0, 0), (0, 1, 1)) box = self.box planeSources[0].SetOrigin(box[0][0], box[0][1], box[0][2]) planeSources[0].SetPoint1(box[1][0], box[0][1], box[0][2]) planeSources[0].SetPoint2(box[0][0], box[0][1], box[1][2]) planeSources[1].SetOrigin(box[0][0], box[1][1], box[0][2]) planeSources[1].SetPoint1(box[1][0], box[1][1], box[0][2]) planeSources[1].SetPoint2(box[0][0], box[0][1], box[0][2]) planeSources[2].SetOrigin(box[0][0], box[1][1], box[0][2]) planeSources[2].SetPoint1(box[0][0], box[0][1], box[0][2]) planeSources[2].SetPoint2(box[0][0], box[1][1], box[1][2]) planeSources[0].SetXResolution(5) planeSources[0].SetYResolution(5) planeSources[1].SetXResolution(5) planeSources[1].SetYResolution(5) planeSources[2].SetXResolution(5) planeSources[2].SetYResolution(5) self.Properties.append( IntProperty("plane resolution", self.SetResolution, self.GetResolution)) appendPolyData = vtk.vtkAppendPolyData() for appendIdx in range(planeCnt): appendPolyData.AddInput(planeSources[appendIdx].GetOutput()) self.tubeFilter = [] collectTubes = vtk.vtkAppendPolyData() for tubeIdx in range(planeCnt): edgeFilter = vtk.vtkExtractEdges() edgeFilter.SetInput(planeSources[tubeIdx].GetOutput()) tubeFilter = vtk.vtkTubeFilter() tubeFilter.SetInput(edgeFilter.GetOutput()) tubeFilter.SetRadius(0.05) tubeFilter.SetNumberOfSides(12) self.tubeFilter.append(tubeFilter) collectTubes.AddInput(tubeFilter.GetOutput()) self.Properties.append( FloatProperty("grid thickness", self.SetTubeThickness, self.GetTubeThickness)) tubeMap = vtk.vtkPolyDataMapper() tubeMap.SetInput(collectTubes.GetOutput()) tubeActor = vtk.vtkActor() tubeActor.SetMapper(tubeMap) tubeActor.GetProperty().SetColor(0.1, 0.1, 0.1) self.Properties.append( ColorProperty("grid color", tubeActor.GetProperty().SetColor, tubeActor.GetProperty().GetColor)) self.Properties.append( FloatProperty("grid opacity", tubeActor.GetProperty().SetOpacity, tubeActor.GetProperty().GetOpacity)) self.Properties.append( ChoiceProperty("grid visible", tubeActor.SetVisibility, tubeActor.GetVisibility)) map = vtk.vtkPolyDataMapper() map.SetInput(appendPolyData.GetOutput()) planeActor = vtk.vtkActor() planeActor.SetMapper(map) planeActor.GetProperty().SetColor(.2, .2, .2) self.Properties.append( ColorProperty("plane color", planeActor.GetProperty().SetColor, planeActor.GetProperty().GetColor)) self.Properties.append( FloatProperty("plane opacity", planeActor.GetProperty().SetOpacity, planeActor.GetProperty().GetOpacity)) self.Properties.append( ChoiceProperty("plane visible", planeActor.SetVisibility, planeActor.GetVisibility)) return [planeActor, tubeActor]
def CreateVoxelizedTubeFilter(polydataMesh,voxelNumbers,fiberRadius): """ Creates an image putting cylinders around the edges of a mesh (see paraview tube filter to get an idea of what it's doing). :param: polydataMesh : mesh, used as the skeleton of the image (vtk polydata object) :param: voxelNumbers: virtual image size :param: fiberRadius : cylinder raidus (in voxel unit) :return: image (numpy array) :example: """ print('Create FibersOnMesh') beginTime=time.time() #Prepare the structure image image=np.zeros(voxelNumbers,dtype=np.bool) imageBounds = polydataMesh.GetBounds() margin=fiberRadius gridX=np.linspace(imageBounds[0]-margin,imageBounds[1]+margin,voxelNumbers[0]+1) gridY=np.linspace(imageBounds[2]-margin,imageBounds[3]+margin,voxelNumbers[1]+1) gridZ=np.linspace(imageBounds[4]-margin,imageBounds[5]+margin,voxelNumbers[2]+1) #Extract lines and points edgeExtractor = vtk.vtkExtractEdges() if vtk.vtkVersion.GetVTKMajorVersion()==6: edgeExtractor.SetInputData(polydataMesh) else: edgeExtractor.SetInput(polydataMesh) edgeExtractor.Update() points = edgeExtractor.GetOutput().GetPoints() nVertice = int(points.GetNumberOfPoints()) vertices=[(float(points.GetPoint(iPoint)[0]), float(points.GetPoint(iPoint)[1]), float(points.GetPoint(iPoint)[2])) for iPoint in range(nVertice)] output = edgeExtractor.GetOutput() nFibre = int(output.GetNumberOfCells()) fibres = [ [int(output.GetCell(iFibre).GetPointId(0)), int(output.GetCell(iFibre).GetPointId(1))] for iFibre in range(nFibre)] #Add cylinders and balls to the structure image print(str(nFibre)+' fibers') print(str(nVertice)+' vertices') for iFibre in range(nFibre): print iFibre, iPoint1=fibres[iFibre][0] iPoint2=fibres[iFibre][1] origin=np.array(vertices[iPoint1]) end=np.array(vertices[iPoint2]) height=np.linalg.norm(end-origin) axis=end-origin center=tuple((end+origin)/2) mesh = BasicShapes.CreateCylinder(center,axis,fiberRadius,height) objImage=Voxelization.Voxelize(mesh,gridX,gridY,gridZ,raydirection='xz') image=np.logical_or(image,objImage) #spherical capings of cylinders for iVertice in range(nVertice): print iVertice, center = vertices[iVertice] mesh = BasicShapes.CreateBall(tuple(center),fiberRadius) objImage=Voxelization.Voxelize(mesh,gridX,gridY,gridZ,raydirection='xz') image=np.logical_or(image,objImage) #image = InsertSubimageInImage(image,voxelNumbers,gridRelativePosition) endTime=time.time() print("Time spent : {} s".format(endTime-beginTime)) return image
def Execute(self): if (self.Surface == None): self.PrintError('Error: no Surface.') if (self.Surface.GetPointData().GetArray( self.SurfaceArrayName) == None): self.PrintError('Error: no array with name specified') else: array = self.Surface.GetPointData().GetArray(self.SurfaceArrayName) surface = self.Surface extractEdges = vtk.vtkExtractEdges() extractEdges.SetInputData(surface) extractEdges.Update() surfEdges = extractEdges.GetOutput() if self.Connexity == 1: for n in range(self.Iterations): for i in range(surfEdges.GetNumberOfPoints()): cells = vtk.vtkIdList() surfEdges.GetPointCells(i, cells) vval = 0 ddd = 0 d = 0 N = 0 for j in range(cells.GetNumberOfIds()): points = vtk.vtkIdList() surfEdges.GetCellPoints(cells.GetId(j), points) for k in range(points.GetNumberOfIds()): if points.GetId(k) != i: d = math.sqrt( vtk.vtkMath.Distance2BetweenPoints( surface.GetPoint(i), surface.GetPoint(points.GetId(k)))) dd = 1 / d val = array.GetComponent(points.GetId(k), 0) #*dd N = N + 1 vval = vval + val ddd = ddd + dd val = array.GetComponent(i, 0) vval = vval / (N) newval = self.Relaxation * vval + (1 - self.Relaxation) * val array.SetTuple1(i, newval) elif self.Connexity == 2: for n in range(self.Iterations): for i in range(surfEdges.GetNumberOfPoints()): cells = vtk.vtkIdList() surfEdges.GetPointCells(i, cells) pointlist = vtk.vtkIdList() vval = 0 ddd = 0 d = 0 N = 0 for j in range(cells.GetNumberOfIds()): points = vtk.vtkIdList() surfEdges.GetCellPoints(cells.GetId(j), points) for k in range(points.GetNumberOfIds()): if points.GetId(k) != i: pointlist.InsertUniqueId(points.GetId(k)) cells2 = vtk.vtkIdList() surfEdges.GetPointCells(i, cells2) for p in range(cells2.GetNumberOfIds()): points2 = vtk.vtkIdList() surfEdges.GetCellPoints( cells2.GetId(j), points2) for q in range(points2.GetNumberOfIds()): if points2.GetId(k) != i: pointlist.InsertUniqueId( points2.GetId(k)) N = pointlist.GetNumberOfIds() for j in range(pointlist.GetNumberOfIds()): d = math.sqrt( vtk.vtkMath.Distance2BetweenPoints( surface.GetPoint(i), surface.GetPoint(pointlist.GetId(j)))) dd = 1 / d val = array.GetComponent(pointlist.GetId(j), 0) vval = vval + val ddd = ddd + dd val = array.GetComponent(i, 0) vval = vval / (N) newval = self.Relaxation * vval + (1 - self.Relaxation) * val array.SetTuple1(i, newval) else: self.PrintError('Error: wrong connexity') self.Surface = surface
def load_vtk_legacy_file(self, file): """ Loads the vtk mesh and displays the scalar data in a color map. Allows further postprocessing to be done, such as grayscale and contour plots. """ if hasattr(self, "mesh_actor"): self.ren.RemoveActor(self.mesh_actor) self.ren.RemoveActor(self.sbActor) if file is None: file, _ = get_file("*.vtk") self.ui.statLabel.setText("Reading %s for mesh . . ." % file) mesh_source = vtk.vtkUnstructuredGridReader() mesh_source.SetFileName(file) # read scalar to vtk mesh_source.SetScalarsName("S33") mesh_source.Update() mesh_reader_output = mesh_source.GetOutput() # bounds for axis bounds = mesh_reader_output.GetBounds() # show element edges edges = vtk.vtkExtractEdges() edges.SetInputConnection(mesh_source.GetOutputPort()) edges.Update() # lookup table and scalar range for a vtk file mesh_lookup_table = vtk.vtkLookupTable() # make scalar red = max; blue = min self.ui.statLabel.setText("Building lookup table . . .") self.draw_color_range(mesh_lookup_table) mesh_lookup_table.Build() scalar_range = mesh_reader_output.GetScalarRange() # mesh data set self.mesh_mapper = vtk.vtkDataSetMapper() self.mesh_mapper.SetInputData(mesh_reader_output) self.mesh_mapper.SetScalarRange(scalar_range) self.mesh_mapper.SetLookupTable(mesh_lookup_table) #define actors self.mesh_actor = vtk.vtkActor() # self.sbActor = vtk.vtkScalarBarActor() # #the scalar bar widget is associated with the qt interactor box scalar_bar_widget = vtk.vtkScalarBarWidget() scalar_bar_widget.SetInteractor(self.iren) # scalar_bar_widget.SetCurrentRenderer(self.ren.GetRenderer()) # scalar_bar_widget.SetDefaultRenderer(self.ren.GetRenderer()) scalar_bar_widget.SetEnabled(True) scalar_bar_widget.RepositionableOn() scalar_bar_widget.On() # define scalar bar actor self.sbActor = scalar_bar_widget.GetScalarBarActor() # self.sbActor.SetOrientationToVertical() self.sbActor.SetLookupTable(mesh_lookup_table) self.sbActor.SetTitle("S33") scalarBarRep = scalar_bar_widget.GetRepresentation() scalarBarRep.GetPositionCoordinate().SetValue(0.01, 0.01) scalarBarRep.GetPosition2Coordinate().SetValue(0.09, 0.9) #attempt to change scalebar properties [ineffective] propT = vtk.vtkTextProperty() propL = vtk.vtkTextProperty() propT.SetFontFamilyToArial() # propT.ItalicOff() propT.BoldOn() propL.BoldOff() propL.SetFontSize(1) propT.SetFontSize(2) self.sbActor.SetTitleTextProperty(propT) self.sbActor.SetLabelTextProperty(propL) self.sbActor.GetLabelTextProperty().SetFontSize(7) self.sbActor.GetTitleTextProperty().SetFontSize(7) self.sbActor.SetLabelFormat("%.1f") #define the mesh actor properties self.mesh_actor.SetMapper(self.mesh_mapper) self.mesh_actor.GetProperty().SetLineWidth(1) self.mesh_actor.GetProperty().EdgeVisibilityOn() #display the actors self.ren.AddActor(self.mesh_actor) self.ren.AddActor(self.sbActor) #get boundary of mesh self.limits = mesh_reader_output.GetBounds() self.ui.vtkWidget.setFocus() self.AddAxis(self.limits, 1) xyview_post(self.ren, self.ren.GetActiveCamera(), self.cp, self.fp) #sorts out the camera issue self.ui.vtkWidget.update() self.ui.statLabel.setText("Loaded results. Idle.") QtWidgets.QApplication.processEvents()
#!/usr/bin/env python import vtk from vtk.test import Testing from vtk.util.misc import vtkGetDataRoot VTK_DATA_ROOT = vtkGetDataRoot() ### SetUp the pipeline FormMesh = vtk.vtkRectilinearGridToTetrahedra() FormMesh.SetInput(4,2,2,1,1,1,0.001) FormMesh.RememberVoxelIdOn() TetraEdges = vtk.vtkExtractEdges() TetraEdges.SetInputConnection(FormMesh.GetOutputPort()) tubes = vtk.vtkTubeFilter() tubes.SetInputConnection(TetraEdges.GetOutputPort()) tubes.SetRadius(0.05) tubes.SetNumberOfSides(6) ### Run the pipeline 3 times, with different conversions to TetMesh Tubes1 = vtk.vtkPolyData() FormMesh.SetTetraPerCellTo5() tubes.Update() Tubes1.DeepCopy(tubes.GetOutput()) Tubes2 = vtk.vtkPolyData() FormMesh.SetTetraPerCellTo6() tubes.Update() Tubes2.DeepCopy(tubes.GetOutput()) Tubes3 = vtk.vtkPolyData() FormMesh.SetTetraPerCellTo12() tubes.Update() Tubes3.DeepCopy(tubes.GetOutput()) ### Run the pipeline once more, this time converting some cells to ### 5 and some data to 12 TetMesh
def extractedges(surface): """Extract edges of a surface mesh, i.e. the edges of all mesh elements.""" extractor = vtk.vtkExtractEdges() extractor.SetInput(surface) extractor.Update() return extractor.GetOutput()
def main(): colors = vtk.vtkNamedColors() # PART 1 Make some Data. # Make a tree. root = vtk.vtkMultiBlockDataSet() branch = vtk.vtkMultiBlockDataSet() root.SetBlock(0, branch) # Make some leaves. leaf1 = vtk.vtkSphereSource() leaf1.SetCenter(0, 0, 0) leaf1.Update() branch.SetBlock(0, leaf1.GetOutput()) leaf2 = vtk.vtkSphereSource() leaf2.SetCenter(1.75, 2.5, 0) leaf2.SetRadius(1.5) leaf2.Update() branch.SetBlock(1, leaf2.GetOutput()) leaf3 = vtk.vtkSphereSource() leaf3.SetCenter(4, 0, 0) leaf3.SetRadius(2) leaf3.Update() root.SetBlock(1, leaf3.GetOutput()) # PART 2 Do something with the data # a non composite aware filter, the pipeline will iterate edges = vtk.vtkExtractEdges() edges.SetInputData(root) # PART 3 Show the data # also demonstrate a composite aware filter # this filter aggregates all blocks into one polydata # this is handy for display, although fairly limited # see vtkCompositePolyDataMapper2 for something better polydata = vtk.vtkCompositeDataGeometryFilter() polydata.SetInputConnection(edges.GetOutputPort()) # Create the Renderer, RenderWindow, and RenderWindowInteractor. renderer = vtk.vtkRenderer() renderWindow = vtk.vtkRenderWindow() renderWindow.AddRenderer(renderer) renderWindowInteractor = vtk.vtkRenderWindowInteractor() renderWindowInteractor.SetRenderWindow(renderWindow) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(0, polydata.GetOutputPort(0)) actor = vtk.vtkActor() actor.GetProperty().SetColor(colors.GetColor3d('Yellow')) actor.GetProperty().SetLineWidth(2) actor.SetMapper(mapper) # Enable user interface interactor. renderer.AddActor(actor) renderer.SetBackground(colors.GetColor3d('CornflowerBlue')) renderWindow.SetWindowName('MultiBlockDataSet') renderWindow.Render() renderWindowInteractor.Start()
Ids.InsertNextId(5) grid = vtk.vtkUnstructuredGrid() grid.Allocate(10, 10) grid.InsertNextCell(13, Ids) grid.SetPoints(Points) grid.GetPointData().SetScalars(Scalars) # Clip the wedge clipper = vtk.vtkClipDataSet() clipper.SetInputData(grid) clipper.SetValue(0.5) # build tubes for the triangle edges # wedgeEdges = vtk.vtkExtractEdges() wedgeEdges.SetInputConnection(clipper.GetOutputPort()) wedgeEdgeTubes = vtk.vtkTubeFilter() wedgeEdgeTubes.SetInputConnection(wedgeEdges.GetOutputPort()) wedgeEdgeTubes.SetRadius(.005) wedgeEdgeTubes.SetNumberOfSides(6) wedgeEdgeMapper = vtk.vtkPolyDataMapper() wedgeEdgeMapper.SetInputConnection(wedgeEdgeTubes.GetOutputPort()) wedgeEdgeMapper.ScalarVisibilityOff() wedgeEdgeActor = vtk.vtkActor() wedgeEdgeActor.SetMapper(wedgeEdgeMapper) wedgeEdgeActor.GetProperty().SetDiffuseColor(GetRGBColor('lamp_black')) wedgeEdgeActor.GetProperty().SetSpecular(.4) wedgeEdgeActor.GetProperty().SetSpecularPower(10) # shrink the triangles so we can see each one
def vtksetup(points, color=None, radius=None): # Create a polydata with the points we just created. profile = vtk.vtkPolyData() profile.SetPoints(points) # Perform a 2D Delaunay triangulation on them. delny = vtk.vtkDelaunay2D() delny.SetInput(profile) delny.SetTolerance(0.001) mapMesh = vtk.vtkPolyDataMapper() mapMesh.SetInputConnection(delny.GetOutputPort()) meshActor = vtk.vtkActor() meshActor.SetMapper(mapMesh) meshActor.GetProperty().SetColor(.1, .2, .1) # Construct the surface and create isosurface. #surf = vtk.vtkSurfaceReconstructionFilter() #surf.SetInput(pointSource.GetPolyDataOutput()) cf = vtk.vtkPolyData() #cf = vtk.vtkContourFilter() cf.SetPoints(points) #cf.SetInput(surf.GetOutput()) #cf.SetValue(0, 0.0) ## map = vtk.vtkPolyDataMapper() ## map.SetInput(reverse.GetOutput()) ## map.ScalarVisibilityOff() surfaceActor = vtk.vtkActor() surfaceActor.SetMapper(map) surfaceActor.GetProperty().SetDiffuseColor(1.0000, 0.3882, 0.2784) surfaceActor.GetProperty().SetSpecularColor(1, 1, 1) surfaceActor.GetProperty().SetSpecular(.4) surfaceActor.GetProperty().SetSpecularPower(50) # We will now create a nice looking mesh by wrapping the edges in tubes, # and putting fat spheres at the points. extract = vtk.vtkExtractEdges() extract.SetInputConnection(delny.GetOutputPort()) ball = vtk.vtkSphereSource() if radius == None: rad = .002 else: rad = radius ball.SetRadius(rad) ball.SetThetaResolution(5) ball.SetPhiResolution(5) balls = vtk.vtkGlyph3D() balls.SetInputConnection(delny.GetOutputPort()) balls.SetSourceConnection(ball.GetOutputPort()) mapBalls = vtk.vtkPolyDataMapper() mapBalls.SetInputConnection(balls.GetOutputPort()) ballActor = vtk.vtkActor() ballActor.SetMapper(mapBalls) if color == None: ballcolor = red else: ballcolor = color ballActor.GetProperty().SetColor(ballcolor) ballActor.GetProperty().SetSpecularColor(0, 0, 0) ballActor.GetProperty().SetSpecular(0.3) ballActor.GetProperty().SetSpecularPower(100) ballActor.GetProperty().SetAmbient(0.2) ballActor.GetProperty().SetDiffuse(0.8) return ballActor
def marching_cubes(mcCases): color = vtk.vtkNamedColors() renWin = vtk.vtkRenderWindow() renWin.SetSize(640, 480) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) renderers = list() gridSize = ((len(mcCases) + 3) // 4) * 4 if len(mcCases) < 4: gridSize = len(mcCases) print("gridSize:", gridSize) for i in range(0, gridSize): # Create the Renderer renderer = vtk.vtkRenderer() renderers.append(renderer) renWin.AddRenderer(renderer) for i in range(0, len(mcCases)): # Define a Single Cube Scalars = vtk.vtkFloatArray() Scalars.InsertNextValue(1.0) Scalars.InsertNextValue(0.0) Scalars.InsertNextValue(0.0) Scalars.InsertNextValue(1.0) Scalars.InsertNextValue(0.0) Scalars.InsertNextValue(0.0) Scalars.InsertNextValue(0.0) Scalars.InsertNextValue(0.0) Points = vtk.vtkPoints() Points.InsertNextPoint(0, 0, 0) Points.InsertNextPoint(1, 0, 0) Points.InsertNextPoint(1, 1, 0) Points.InsertNextPoint(0, 1, 0) Points.InsertNextPoint(0, 0, 1) Points.InsertNextPoint(1, 0, 1) Points.InsertNextPoint(1, 1, 1) Points.InsertNextPoint(0, 1, 1) Ids = vtk.vtkIdList() Ids.InsertNextId(0) Ids.InsertNextId(1) Ids.InsertNextId(2) Ids.InsertNextId(3) Ids.InsertNextId(4) Ids.InsertNextId(5) Ids.InsertNextId(6) Ids.InsertNextId(7) Grid = vtk.vtkUnstructuredGrid() Grid.Allocate(10, 10) Grid.InsertNextCell(12, Ids) Grid.SetPoints(Points) Grid.GetPointData().SetScalars(Scalars) # Find the triangles that lie along the 0.5 contour in this cube. Marching = vtk.vtkContourFilter() Marching.SetInputData(Grid) Marching.SetValue(0, 0.5) Marching.Update() # Extract the edges of the triangles just found. triangleEdges = vtk.vtkExtractEdges() triangleEdges.SetInputConnection(Marching.GetOutputPort()) # Draw the edges as tubes instead of lines. Also create the associated # mapper and actor to display the tubes. triangleEdgeTubes = vtk.vtkTubeFilter() triangleEdgeTubes.SetInputConnection(triangleEdges.GetOutputPort()) triangleEdgeTubes.SetRadius(.005) triangleEdgeTubes.SetNumberOfSides(6) triangleEdgeTubes.UseDefaultNormalOn() triangleEdgeTubes.SetDefaultNormal(.577, .577, .577) triangleEdgeMapper = vtk.vtkPolyDataMapper() triangleEdgeMapper.SetInputConnection( triangleEdgeTubes.GetOutputPort()) triangleEdgeMapper.ScalarVisibilityOff() triangleEdgeActor = vtk.vtkActor() triangleEdgeActor.SetMapper(triangleEdgeMapper) triangleEdgeActor.GetProperty().SetDiffuseColor( color.GetColor3d("lamp_black")) triangleEdgeActor.GetProperty().SetSpecular(.4) triangleEdgeActor.GetProperty().SetSpecularPower(10) # Shrink the triangles we found earlier. Create the associated mapper # and actor. Set the opacity of the shrunken triangles. aShrinker = vtk.vtkShrinkPolyData() aShrinker.SetShrinkFactor(1) aShrinker.SetInputConnection(Marching.GetOutputPort()) aMapper = vtk.vtkPolyDataMapper() aMapper.ScalarVisibilityOff() aMapper.SetInputConnection(aShrinker.GetOutputPort()) Triangles = vtk.vtkActor() Triangles.SetMapper(aMapper) Triangles.GetProperty().SetDiffuseColor(color.GetColor3d("banana")) Triangles.GetProperty().SetOpacity(.6) # Draw a cube the same size and at the same position as the one # created previously. Extract the edges because we only want to see # the outline of the cube. Pass the edges through a vtkTubeFilter so # they are displayed as tubes rather than lines. CubeModel = vtk.vtkCubeSource() CubeModel.SetCenter(.5, .5, .5) Edges = vtk.vtkExtractEdges() Edges.SetInputConnection(CubeModel.GetOutputPort()) Tubes = vtk.vtkTubeFilter() Tubes.SetInputConnection(Edges.GetOutputPort()) Tubes.SetRadius(.01) Tubes.SetNumberOfSides(6) Tubes.UseDefaultNormalOn() Tubes.SetDefaultNormal(.577, .577, .577) # Create the mapper and actor to display the cube edges. TubeMapper = vtk.vtkPolyDataMapper() TubeMapper.SetInputConnection(Tubes.GetOutputPort()) CubeEdges = vtk.vtkActor() CubeEdges.SetMapper(TubeMapper) CubeEdges.GetProperty().SetDiffuseColor(color.GetColor3d("khaki")) CubeEdges.GetProperty().SetSpecular(.4) CubeEdges.GetProperty().SetSpecularPower(10) # Create a sphere to use as a glyph source for vtkGlyph3D. Sphere = vtk.vtkSphereSource() Sphere.SetRadius(0.04) Sphere.SetPhiResolution(20) Sphere.SetThetaResolution(20) # Remove the part of the cube with data values below 0.5. ThresholdIn = vtk.vtkThresholdPoints() ThresholdIn.SetInputData(Grid) ThresholdIn.ThresholdByUpper(.5) # Display spheres at the vertices remaining in the cube data set after # it was passed through vtkThresholdPoints. Vertices = vtk.vtkGlyph3D() Vertices.SetInputConnection(ThresholdIn.GetOutputPort()) Vertices.SetSourceConnection(Sphere.GetOutputPort()) # Create a mapper and actor to display the glyphs. SphereMapper = vtk.vtkPolyDataMapper() SphereMapper.SetInputConnection(Vertices.GetOutputPort()) SphereMapper.ScalarVisibilityOff() CubeVertices = vtk.vtkActor() CubeVertices.SetMapper(SphereMapper) CubeVertices.GetProperty().SetDiffuseColor(color.GetColor3d("tomato")) # Define the text for the label caseLabel = vtk.vtkVectorText() caseLabel.SetText("Case 1") # Set up a transform to move the label to a new position. aLabelTransform = vtk.vtkTransform() aLabelTransform.Identity() aLabelTransform.Translate(-0.2, 0, 1.25) aLabelTransform.Scale(.05, .05, .05) # Move the label to a new position. labelTransform = vtk.vtkTransformPolyDataFilter() labelTransform.SetTransform(aLabelTransform) labelTransform.SetInputConnection(caseLabel.GetOutputPort()) # Create a mapper and actor to display the text. labelMapper = vtk.vtkPolyDataMapper() labelMapper.SetInputConnection(labelTransform.GetOutputPort()) labelActor = vtk.vtkActor() labelActor.SetMapper(labelMapper) # Define the base that the cube sits on. Create its associated mapper # and actor. Set the position of the actor. baseModel = vtk.vtkCubeSource() baseModel.SetXLength(1.5) baseModel.SetYLength(.01) baseModel.SetZLength(1.5) baseMapper = vtk.vtkPolyDataMapper() baseMapper.SetInputConnection(baseModel.GetOutputPort()) base = vtk.vtkActor() base.SetMapper(baseMapper) base.SetPosition(.5, -0.09, .5) # Set the scalar values for this case of marching cubes. # A negative case number will generate a complementary case mcCase = mcCases[i] if mcCase < 0: cases[-mcCase](Scalars, caseLabel, 0, 1) else: cases[mcCase](Scalars, caseLabel, 1, 0) # Force the grid to update. Grid.Modified() # Add the actors to the renderer renderers[i].AddActor(triangleEdgeActor) renderers[i].AddActor(base) renderers[i].AddActor(labelActor) renderers[i].AddActor(CubeEdges) renderers[i].AddActor(CubeVertices) renderers[i].AddActor(Triangles) # Set the background color. renderers[i].SetBackground(color.GetColor3d("slate_grey")) # Position the camera. renderers[i].GetActiveCamera().Dolly(1.2) renderers[i].GetActiveCamera().Azimuth(30) renderers[i].GetActiveCamera().Elevation(20) renderers[i].ResetCamera() renderers[i].ResetCameraClippingRange() if i > 0: renderers[i].SetActiveCamera(renderers[0].GetActiveCamera()) # Setup viewports for the renderers rendererSize = 300 xGridDimensions = 4 if len(mcCases) < 4: xGridDimensions = len(mcCases) yGridDimensions = (len(mcCases) - 1) // 4 + 1 print("x, y:", xGridDimensions, ",", yGridDimensions) renWin.SetSize(rendererSize * xGridDimensions, rendererSize * yGridDimensions) for row in range(0, yGridDimensions): for col in range(0, xGridDimensions): index = row * xGridDimensions + col # (xmin, ymin, xmax, ymax) viewport = [ float(col) / xGridDimensions, float(yGridDimensions - (row + 1)) / yGridDimensions, float(col + 1) / xGridDimensions, float(yGridDimensions - row) / yGridDimensions ] renderers[index].SetViewport(viewport) iren.Initialize() renWin.Render() iren.Start()
import vtk from vtk.util.colors import * cubeSource = vtk.vtkCubeSource() cubeSource.SetBounds(-5, 5, -5, 5, -5, 5) ee = vtk.vtkExtractEdges() ee.SetInput(cubeSource.GetOutput()) cubeTube = vtk.vtkTubeFilter() cubeTube.SetRadius(0.1) cubeTube.SetNumberOfSides(20) cubeTube.UseDefaultNormalOn() cubeTube.SetDefaultNormal(.5, .5, .5) cubeTube.SetInput(ee.GetOutput()) cubeMapper = vtk.vtkPolyDataMapper() cubeMapper.SetInput(cubeTube.GetOutput()) cubeActor = vtk.vtkActor() cubeActor.SetMapper(cubeMapper) cubeActor.GetProperty().SetDiffuseColor(lamp_black) cubeActor.GetProperty().SetSpecular(0.4) cubeActor.GetProperty().SetSpecularPower(10) cubeMapper2 = vtk.vtkPolyDataMapper() cubeMapper2.SetInput(cubeSource.GetOutput()) cubeActor2 = vtk.vtkActor() cubeActor2.SetMapper(cubeMapper2) cubeActor2.GetProperty().SetDiffuseColor(banana) #cubeActor2.GetProperty().SetOpacity(0.9)
def main(): colors = vtk.vtkNamedColors() filename = get_program_parameters() # Create the reader for the data. print('Loading ', filename) reader = vtk.vtkUnstructuredGridReader() reader.SetFileName(filename) reader.Update() extractEdges = vtk.vtkExtractEdges() extractEdges.SetInputConnection(reader.GetOutputPort()) legendValues = vtk.vtkVariantArray() it = reader.GetOutput().NewCellIterator() it.InitTraversal() while not it.IsDoneWithTraversal(): cell = vtk.vtkGenericCell() it.GetCell(cell) cellName = vtk.vtkCellTypes.GetClassNameFromTypeId(cell.GetCellType()) print(cellName, 'NumberOfPoints:', cell.GetNumberOfPoints(), 'CellDimension:', cell.GetCellDimension()) legendValues.InsertNextValue(cellName) it.GoToNextCell() # Tube the edges tubes = vtk.vtkTubeFilter() tubes.SetInputConnection(extractEdges.GetOutputPort()) tubes.SetRadius(.05) tubes.SetNumberOfSides(21) edgeMapper = vtk.vtkPolyDataMapper() edgeMapper.SetInputConnection(tubes.GetOutputPort()) edgeMapper.SetScalarRange(0, 26) edgeActor = vtk.vtkActor() edgeActor.SetMapper(edgeMapper) edgeActor.GetProperty().SetSpecular(0.6) edgeActor.GetProperty().SetSpecularPower(30) # Glyph the points sphere = vtk.vtkSphereSource() sphere.SetPhiResolution(21) sphere.SetThetaResolution(21) sphere.SetRadius(0.08) pointMapper = vtk.vtkGlyph3DMapper() pointMapper.SetInputConnection(reader.GetOutputPort()) pointMapper.SetSourceConnection(sphere.GetOutputPort()) pointMapper.ScalingOff() pointMapper.ScalarVisibilityOff() pointActor = vtk.vtkActor() pointActor.SetMapper(pointMapper) pointActor.GetProperty().SetDiffuseColor(colors.GetColor3d('Banana')) pointActor.GetProperty().SetSpecular(0.6) pointActor.GetProperty().SetSpecularColor(1.0, 1.0, 1.0) pointActor.GetProperty().SetSpecularPower(100) # Label the points labelMapper = vtk.vtkLabeledDataMapper() labelMapper.SetInputConnection(reader.GetOutputPort()) labelActor = vtk.vtkActor2D() labelActor.SetMapper(labelMapper) # The geometry geometryShrink = vtk.vtkShrinkFilter() geometryShrink.SetInputConnection(reader.GetOutputPort()) geometryShrink.SetShrinkFactor(0.8) # NOTE: We must copy the originalLut because the CategoricalLegend # needs an indexed lookup table, but the geometryMapper uses a # non-index lookup table categoricalLut = vtk.vtkLookupTable() originalLut = reader.GetOutput().GetCellData().GetScalars().GetLookupTable( ) categoricalLut.DeepCopy(originalLut) categoricalLut.IndexedLookupOn() geometryMapper = vtk.vtkDataSetMapper() geometryMapper.SetInputConnection(geometryShrink.GetOutputPort()) geometryMapper.SetScalarModeToUseCellData() geometryMapper.SetScalarRange(0, 11) geometryActor = vtk.vtkActor() geometryActor.SetMapper(geometryMapper) geometryActor.GetProperty().SetLineWidth(3) geometryActor.GetProperty().EdgeVisibilityOn() geometryActor.GetProperty().SetEdgeColor(0, 0, 0) # Legend for v in range(0, legendValues.GetNumberOfTuples()): categoricalLut.SetAnnotation(legendValues.GetValue(v), legendValues.GetValue(v).ToString()) legend = vtk.vtkCategoryLegend() legend.SetScalarsToColors(categoricalLut) legend.SetValues(legendValues) legend.SetTitle('Cell Type') legend.GetBrush().SetColor(colors.GetColor4ub('Silver')) placeLegend = vtk.vtkContextTransform() placeLegend.AddItem(legend) placeLegend.Translate(640 - 20, 480 - 12 * 16) contextView = vtk.vtkContextView() contextView.GetScene().AddItem(placeLegend) renderer = contextView.GetRenderer() renderWindow = contextView.GetRenderWindow() renderWindowInteractor = vtk.vtkRenderWindowInteractor() renderWindowInteractor.SetRenderWindow(renderWindow) renderer.AddActor(geometryActor) renderer.AddActor(labelActor) renderer.AddActor(edgeActor) renderer.AddActor(pointActor) renderer.SetBackground(colors.GetColor3d('SlateGray')) aCamera = vtk.vtkCamera() aCamera.Azimuth(-40.0) aCamera.Elevation(50.0) renderer.SetActiveCamera(aCamera) renderer.ResetCamera() renderWindow.SetSize(640, 480) renderWindow.SetWindowName('ReadLegacyUnstructuredGrid') renderWindow.Render() renderWindowInteractor.Start()
lut.SetValueRange(0,1) lut.SetNumberOfColors(len(clip_values)-1) # Displays the contour bands bands_mapper = vtk.vtkPolyDataMapper() bands_mapper.SetInputDataObject(poly) bands_mapper.ScalarVisibilityOn() bands_mapper.SetScalarModeToUseCellData() bands_mapper.SetScalarRange(out_scalars.GetRange()) bands_mapper.SetLookupTable(lut) bands_mapper.UseLookupTableScalarRangeOn() bands_actor = vtk.vtkActor() bands_actor.SetMapper(bands_mapper) # Displays the cell edges of the contour bands band_cell_edges=vtk.vtkExtractEdges() band_cell_edges.SetInputDataObject(poly) band_cell_edges_mapper = vtk.vtkPolyDataMapper() band_cell_edges_mapper.ScalarVisibilityOff() band_cell_edges_mapper.SetInputConnection(band_cell_edges.GetOutputPort()) band_cell_edges_actor = vtk.vtkActor() band_cell_edges_actor.SetMapper(band_cell_edges_mapper) band_cell_edges_actor.GetProperty().SetColor(.4,.4,.4) # Displays the contour edges generated by the BPDCF, # somewhat thicker than the cell edges band_edges_mapper = vtk.vtkPolyDataMapper() band_edges_mapper.SetInputConnection(bands.GetOutputPort(1)) band_edges_actor = vtk.vtkActor() band_edges_actor.SetMapper(band_edges_mapper) band_edges_actor.GetProperty().SetColor(1,1,1)
def main(): colors = vtk.vtkNamedColors() # Generate some "random" points. points = vtk.vtkPoints() randomSequence = vtk.vtkMinimalStandardRandomSequence() randomSequence.SetSeed(1) for i in range(0, 50): p1 = randomSequence.GetValue() randomSequence.Next() p2 = randomSequence.GetValue() randomSequence.Next() points.InsertPoint(i, p1, p2, 0.0) # Create a polydata with the points we just created. profile = vtk.vtkPolyData() profile.SetPoints(points) # Perform a 2D Delaunay triangulation on them. delny = vtk.vtkDelaunay2D() delny.SetInputData(profile) delny.SetTolerance(0.001) mapMesh = vtk.vtkPolyDataMapper() mapMesh.SetInputConnection(delny.GetOutputPort()) meshActor = vtk.vtkActor() meshActor.SetMapper(mapMesh) meshActor.GetProperty().SetColor(colors.GetColor3d('MidnightBlue')) # We will now create a nice looking mesh by wrapping the edges in tubes, # and putting fat spheres at the points. extract = vtk.vtkExtractEdges() extract.SetInputConnection(delny.GetOutputPort()) tubes = vtk.vtkTubeFilter() tubes.SetInputConnection(extract.GetOutputPort()) tubes.SetRadius(0.01) tubes.SetNumberOfSides(6) mapEdges = vtk.vtkPolyDataMapper() mapEdges.SetInputConnection(tubes.GetOutputPort()) edgeActor = vtk.vtkActor() edgeActor.SetMapper(mapEdges) edgeActor.GetProperty().SetColor(colors.GetColor3d('peacock')) edgeActor.GetProperty().SetSpecularColor(1, 1, 1) edgeActor.GetProperty().SetSpecular(0.3) edgeActor.GetProperty().SetSpecularPower(20) edgeActor.GetProperty().SetAmbient(0.2) edgeActor.GetProperty().SetDiffuse(0.8) ball = vtk.vtkSphereSource() ball.SetRadius(0.025) ball.SetThetaResolution(12) ball.SetPhiResolution(12) balls = vtk.vtkGlyph3D() balls.SetInputConnection(delny.GetOutputPort()) balls.SetSourceConnection(ball.GetOutputPort()) mapBalls = vtk.vtkPolyDataMapper() mapBalls.SetInputConnection(balls.GetOutputPort()) ballActor = vtk.vtkActor() ballActor.SetMapper(mapBalls) ballActor.GetProperty().SetColor(colors.GetColor3d('hot_pink')) ballActor.GetProperty().SetSpecularColor(1, 1, 1) ballActor.GetProperty().SetSpecular(0.3) ballActor.GetProperty().SetSpecularPower(20) ballActor.GetProperty().SetAmbient(0.2) ballActor.GetProperty().SetDiffuse(0.8) # Create the rendering window, renderer, and interactive renderer. ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # Add the actors to the renderer, set the background and size. ren.AddActor(ballActor) ren.AddActor(edgeActor) ren.SetBackground(colors.GetColor3d('AliceBlue')) renWin.SetSize(512, 512) renWin.SetWindowName('DelaunayMesh') ren.ResetCamera() ren.GetActiveCamera().Zoom(1.3) # Interact with the data. iren.Initialize() renWin.Render() iren.Start()
model.SetMapper(dataMapper) model.GetProperty().SetColor(1, 0, 0) obb = vtk.vtkOBBTree() obb.SetMaxLevel(10) obb.SetNumberOfCellsPerNode(5) obb.AutomaticOff() boxes = vtk.vtkSpatialRepresentationFilter() boxes.SetInputConnection(transPD.GetOutputPort()) boxes.SetSpatialRepresentation(obb) boxes.SetGenerateLeaves(1) boxes.Update() output = boxes.GetOutput().GetBlock(boxes.GetMaximumLevel() + 1) boxEdges = vtk.vtkExtractEdges() boxEdges.SetInputData(output) boxMapper = vtk.vtkPolyDataMapper() boxMapper.SetInputConnection(boxEdges.GetOutputPort()) boxMapper.SetResolveCoincidentTopology(1) boxActor = vtk.vtkActor() boxActor.SetMapper(boxMapper) boxActor.GetProperty().SetAmbient(1) boxActor.GetProperty().SetDiffuse(0) boxActor.GetProperty().SetRepresentationToWireframe() ren1 = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren1)
import vtk, os, sys from vtk.test import Testing ss = vtk.vtkSphereSource() #make mesh to test with af = vtk.vtkElevationFilter() #add some attributes af.SetInputConnection(ss.GetOutputPort()) ef = vtk.vtkExtractEdges() #make lines to test ef.SetInputConnection(af.GetOutputPort()) gf = vtk.vtkGlyph3D() #make verts to test pts = vtk.vtkPoints() pts.InsertNextPoint(0,0,0) verts = vtk.vtkCellArray() avert = vtk.vtkVertex() avert.GetPointIds().SetId(0, 0) verts.InsertNextCell(avert) onevertglyph = vtk.vtkPolyData() onevertglyph.SetPoints(pts) onevertglyph.SetVerts(verts) gf.SetSourceData(onevertglyph) gf.SetInputConnection(af.GetOutputPort()) testwrites = ["points","lines","mesh"] failed = False for datasetString in testwrites: if datasetString == "points": toshow=gf elif datasetString == "lines": toshow = ef
def returnActors(slef, skel, mode): sx=skel.MS.size()[0] sy=skel.MS.size()[1] smax=sx if smax<sy: smax=sy points = vtk.vtkPoints() ndindex={} i=0 for nd in skel.nodes: if mode==0: points.InsertPoint(i, nd.position().x, nd.position().y, 0) elif mode==1: theta=2*vtk.vtkMath.Pi()*nd.position().x/sx radius=sx/(2.0*vtk.vtkMath.Pi()) points.InsertPoint(i, radius*math.cos(theta), nd.position().y, radius*math.sin(theta)) elif mode==2: theta=2*vtk.vtkMath.Pi()*nd.position().y/sy radius=sy/(2.0*vtk.vtkMath.Pi()) points.InsertPoint(i, nd.position().x, radius*math.cos(theta), radius*math.sin(theta)) elif mode==3: theta=2*vtk.vtkMath.Pi()*nd.position().y/sy radius=sy/(2.0*vtk.vtkMath.Pi()) ry=radius*math.cos(theta) R=sx/(2.0*vtk.vtkMath.Pi())+radius+ry theta2=2*vtk.vtkMath.Pi()*nd.position().x/sx points.InsertPoint(i, R*math.cos(theta2), R*math.sin(theta2), radius*math.sin(theta)) ndindex[nd.getIndex()]=i i+=1 strips = vtk.vtkCellArray() for el in skel.elements: strips.InsertNextCell(el.nnodes()) if el.nnodes()==4: strips.InsertCellPoint(ndindex[el.nodes[0].getIndex()]) strips.InsertCellPoint(ndindex[el.nodes[1].getIndex()]) strips.InsertCellPoint(ndindex[el.nodes[3].getIndex()]) strips.InsertCellPoint(ndindex[el.nodes[2].getIndex()]) else: for nd in el.nodes: strips.InsertCellPoint(ndindex[nd.getIndex()]) profile = vtk.vtkPolyData() profile.SetPoints(points) profile.SetStrips(strips) extract = vtk.vtkExtractEdges() extract.SetInput(profile) tubes = vtk.vtkTubeFilter() tubes.SetInputConnection(extract.GetOutputPort()) tubes.SetRadius(0.01*smax) tubes.SetNumberOfSides(6) mapEdges = vtk.vtkPolyDataMapper() mapEdges.SetInputConnection(tubes.GetOutputPort()) edgeActor = vtk.vtkActor() edgeActor.SetMapper(mapEdges) edgeActor.GetProperty().SetColor(peacock) edgeActor.GetProperty().SetSpecularColor(1, 1, 1) edgeActor.GetProperty().SetSpecular(0.3) edgeActor.GetProperty().SetSpecularPower(20) edgeActor.GetProperty().SetAmbient(0.2) edgeActor.GetProperty().SetDiffuse(0.8) ball = vtk.vtkSphereSource() ball.SetRadius(0.025*smax) ball.SetThetaResolution(12) ball.SetPhiResolution(12) balls = vtk.vtkGlyph3D() balls.SetInput(profile) balls.SetSourceConnection(ball.GetOutputPort()) mapBalls = vtk.vtkPolyDataMapper() mapBalls.SetInputConnection(balls.GetOutputPort()) ballActor = vtk.vtkActor() ballActor.SetMapper(mapBalls) ballActor.GetProperty().SetColor(hot_pink) ballActor.GetProperty().SetSpecularColor(1, 1, 1) ballActor.GetProperty().SetSpecular(0.3) ballActor.GetProperty().SetSpecularPower(20) ballActor.GetProperty().SetAmbient(0.2) ballActor.GetProperty().SetDiffuse(0.8) return ballActor, edgeActor
def returnActors(slef, skel, mode): sx = skel.MS.size()[0] sy = skel.MS.size()[1] smax = sx if smax < sy: smax = sy points = vtk.vtkPoints() ndindex = {} i = 0 for nd in skel.nodes: if mode == 0: points.InsertPoint(i, nd.position().x, nd.position().y, 0) elif mode == 1: theta = 2 * vtk.vtkMath.Pi() * nd.position().x / sx radius = sx / (2.0 * vtk.vtkMath.Pi()) points.InsertPoint(i, radius * math.cos(theta), nd.position().y, radius * math.sin(theta)) elif mode == 2: theta = 2 * vtk.vtkMath.Pi() * nd.position().y / sy radius = sy / (2.0 * vtk.vtkMath.Pi()) points.InsertPoint(i, nd.position().x, radius * math.cos(theta), radius * math.sin(theta)) elif mode == 3: theta = 2 * vtk.vtkMath.Pi() * nd.position().y / sy radius = sy / (2.0 * vtk.vtkMath.Pi()) ry = radius * math.cos(theta) R = sx / (2.0 * vtk.vtkMath.Pi()) + radius + ry theta2 = 2 * vtk.vtkMath.Pi() * nd.position().x / sx points.InsertPoint(i, R * math.cos(theta2), R * math.sin(theta2), radius * math.sin(theta)) ndindex[nd.getIndex()] = i i += 1 strips = vtk.vtkCellArray() for el in skel.elements: strips.InsertNextCell(el.nnodes()) if el.nnodes() == 4: strips.InsertCellPoint(ndindex[el.nodes[0].getIndex()]) strips.InsertCellPoint(ndindex[el.nodes[1].getIndex()]) strips.InsertCellPoint(ndindex[el.nodes[3].getIndex()]) strips.InsertCellPoint(ndindex[el.nodes[2].getIndex()]) else: for nd in el.nodes: strips.InsertCellPoint(ndindex[nd.getIndex()]) profile = vtk.vtkPolyData() profile.SetPoints(points) profile.SetStrips(strips) extract = vtk.vtkExtractEdges() extract.SetInput(profile) tubes = vtk.vtkTubeFilter() tubes.SetInputConnection(extract.GetOutputPort()) tubes.SetRadius(0.01 * smax) tubes.SetNumberOfSides(6) mapEdges = vtk.vtkPolyDataMapper() mapEdges.SetInputConnection(tubes.GetOutputPort()) edgeActor = vtk.vtkActor() edgeActor.SetMapper(mapEdges) edgeActor.GetProperty().SetColor(peacock) edgeActor.GetProperty().SetSpecularColor(1, 1, 1) edgeActor.GetProperty().SetSpecular(0.3) edgeActor.GetProperty().SetSpecularPower(20) edgeActor.GetProperty().SetAmbient(0.2) edgeActor.GetProperty().SetDiffuse(0.8) ball = vtk.vtkSphereSource() ball.SetRadius(0.025 * smax) ball.SetThetaResolution(12) ball.SetPhiResolution(12) balls = vtk.vtkGlyph3D() balls.SetInput(profile) balls.SetSourceConnection(ball.GetOutputPort()) mapBalls = vtk.vtkPolyDataMapper() mapBalls.SetInputConnection(balls.GetOutputPort()) ballActor = vtk.vtkActor() ballActor.SetMapper(mapBalls) ballActor.GetProperty().SetColor(hot_pink) ballActor.GetProperty().SetSpecularColor(1, 1, 1) ballActor.GetProperty().SetSpecular(0.3) ballActor.GetProperty().SetSpecularPower(20) ballActor.GetProperty().SetAmbient(0.2) ballActor.GetProperty().SetDiffuse(0.8) return ballActor, edgeActor
def createPipeline(srcLats, srcLons, dstLats, dstLons, nitersData, radius=1.0): # create the src grid pipeline srcN0, srcN1 = srcLats.shape srcNumPts = srcN0 * srcN1 srcSg = vtk.vtkStructuredGrid() srcPt = vtk.vtkPoints() srcPt.SetNumberOfPoints(srcNumPts) k = 0 for i1 in range(srcN1): for i0 in range(srcN0): r = radius * 1.05 x = r * math.cos(srcLats[i0, i1] * math.pi / 180.) * math.cos( srcLons[i0, i1] * math.pi / 180.) y = r * math.cos(srcLats[i0, i1] * math.pi / 180.) * math.sin( srcLons[i0, i1] * math.pi / 180.) z = r * math.sin(srcLats[i0, i1] * math.pi / 180.) srcPt.SetPoint(k, x, y, z) k += 1 srcSg.SetDimensions(1, srcN0, srcN1) srcSg.SetPoints(srcPt) srcEd = vtk.vtkExtractEdges() srcEt = vtk.vtkTubeFilter() srcEm = vtk.vtkPolyDataMapper() srcEa = vtk.vtkActor() srcEt.SetRadius(0.005) srcEd.SetInputData(srcSg) srcEt.SetInputConnection(srcEd.GetOutputPort()) srcEm.SetInputConnection(srcEt.GetOutputPort()) srcEa.SetMapper(srcEm) srcEa.GetProperty().SetColor(0., 1., 0.) #srcEa.GetProperty().SetOpacity(0.5) dstN0, dstN1 = dstLats.shape numPoints = dstN0 * dstN1 sg = vtk.vtkStructuredGrid() pt = vtk.vtkPoints() pt.SetNumberOfPoints(numPoints) ar = vtk.vtkDoubleArray() numPts = nitersData.shape[0] * nitersData.shape[1] ar.SetNumberOfComponents(1) ar.SetNumberOfTuples(numPts) #ar.SetVoidArray(nitersData, 1, 1) k = 0 for i1 in range(dstN1): for i0 in range(dstN0): elev = 0.0 #0.10 * math.log10(nitersData[i0, i1]) r = radius * (1. + elev) x = r * math.cos(dstLats[i0, i1] * math.pi / 180.) * math.cos( dstLons[i0, i1] * math.pi / 180.) y = r * math.cos(dstLats[i0, i1] * math.pi / 180.) * math.sin( dstLons[i0, i1] * math.pi / 180.) z = r * math.sin(dstLats[i0, i1] * math.pi / 180.) pt.SetPoint(k, x, y, z) ar.SetTuple(k, (float(nitersData[i0, i1]), )) k += 1 sg = vtk.vtkStructuredGrid() sg.SetDimensions(1, dstN0, dstN1) sg.SetPoints(pt) sg.GetPointData().SetScalars(ar) lu = vtk.vtkLookupTable() lu.SetScaleToLog10() #lu.SetTableRange(1, 10) lu.SetNumberOfColors(256) lu.SetHueRange(0.666, 0.) lu.Build() # add a scalar bar sb = vtk.vtkScalarBarActor() sb.SetLookupTable(lu) sb.SetTitle("Number of iters") sb.SetNumberOfLabels(4) # show the dst grid dstEd = vtk.vtkExtractEdges() dstEt = vtk.vtkTubeFilter() dstEm = vtk.vtkPolyDataMapper() dstEa = vtk.vtkActor() dstEt.SetRadius(0.005) dstEd.SetInputData(sg) dstEt.SetInputConnection(dstEd.GetOutputPort()) dstEm.SetInputConnection(dstEt.GetOutputPort()) dstEa.SetMapper(dstEm) dstEa.GetProperty().SetColor(1., 0., 0.) #dstEa.GetProperty().SetOpacity(0.5) # show number of iterations as a color plot mp = vtk.vtkDataSetMapper() mp.SetInputData(sg) mp.SetLookupTable(lu) mp.SetScalarRange(1, args.nitermax) ac = vtk.vtkActor() ac.SetMapper(mp) return { 'actors': [ ac, sb, ], 'stuff': (sg, pt, mp, ar, lu, srcSg, srcPt, srcEd, srcEt, srcEm, dstEd, dstEt, dstEm) }
kq_visible_only = vtk.vtkSelectVisiblePoints() kq_visible_only.SetRenderer(ren) kq_visible_only.SetInputConnection(kq_cell_centers.GetOutputPort()) kq_labels = vtk.vtkLabeledDataMapper() kq_labels.SetInputConnection(kq_visible_only.GetOutputPort()) kq_labels.SetLabelModeToLabelScalars() kq_labels.SetLabelFormat("%.0f") kq_labels.GetLabelTextProperty().SetJustificationToCentered() kq_labels.GetLabelTextProperty().SetVerticalJustificationToCentered() kq_labels_actor = vtk.vtkActor2D() kq_labels_actor.SetMapper(kq_labels) ren.AddActor(kq_labels_actor) draw_edges = True if draw_edges: lines = vtk.vtkExtractEdges() if vtk.vtkVersion.GetVTKMajorVersion() >= 6: lines.SetInputData(edges) else: lines.SetInput(edges) tube = vtk.vtkTubeFilter() tube.SetInputConnection(lines.GetOutputPort()) tube.SetRadius(0.005) tube.SetNumberOfSides(20) sphere = vtk.vtkSphereSource() sphere.SetRadius(0.005) sphere.SetPhiResolution(20) sphere.SetThetaResolution(20) vertices = vtk.vtkGlyph3D() if vtk.vtkVersion.GetVTKMajorVersion() >= 6:
def render_demo(): # Step 1. Data Source # Create a sphere geometry sphere_src = vtk.vtkSphereSource() sphere_src.SetRadius(1.0) sphere_src.SetCenter(0.0, 0.0, 0.0) # In reality, vtkSphereSource creates a polygonal approximation (a # triangulation) of a sphere. Set the resolution. sphere_src.SetThetaResolution(20) sphere_src.SetPhiResolution(20) # Step 2. Data Processing # We will visualize the edges of the sphere that we just created. For # that, we must first extract the edges from the sphere triangulation. # VTK makes that easy. edge_extractor = vtk.vtkExtractEdges() # Create a pipeline link between sphere source and edge extractor edge_extractor.SetInputConnection(sphere_src.GetOutputPort()) # Now our edge extractor acts as a second data source: it supplies the # geometry of the edges of the sphere # Step 3. Mappers # Create a set of graphical primitives to represent the sphere sphere_mapper = vtk.vtkPolyDataMapper() # Create a pipeline link between sphere source and mapper sphere_mapper.SetInputConnection(sphere_src.GetOutputPort()) # Similarly, create a mapper for the edges of the sphere edge_mapper = vtk.vtkPolyDataMapper() edge_mapper.SetInputConnection(edge_extractor.GetOutputPort()) # Step 4. Actors # Insert the graphical primitives into the scene to be rendered sphere_actor = vtk.vtkActor() # Assign sphere mapper to actor sphere_actor.SetMapper(sphere_mapper) # The actor now controls the graphical properties of the sphere. We can # access them to change the color of the sphere. The color is set in RGB # mode using values from 0 to 1 for each of the three color channels. # Here we set the color to orange. sphere_actor.GetProperty().SetColor(1, 0.5, 0) # Same thing for the edges of the sphere edge_actor = vtk.vtkActor() edge_actor.SetMapper(edge_mapper) # We want our edges to be drawn in dark green edge_actor.GetProperty().SetColor(0, 0.5, 0) # We also want them to be shown as thick lines edge_actor.GetProperty().SetLineWidth(3) # Step 5. Renderer # Render the scene to form an image that can be displayed my_renderer = vtk.vtkRenderer() # Add all our actors to the renderer my_renderer.AddActor(sphere_actor) my_renderer.AddActor(edge_actor) my_renderer.SetBackground(0.1, 0.2, 0.4) # Step 6. Render Window # Provides a window in which the rendered image can be displayed on the # screen my_window = vtk.vtkRenderWindow() my_window.AddRenderer(my_renderer) # The window size controls the resolution of the final image my_window.SetSize(600, 600) # Step 7. Interactor # Create an interactor: the user will be able to control the # visualization through mouse and keyboard interaction my_interactor = vtk.vtkRenderWindowInteractor() my_interactor.SetRenderWindow(my_window) # IMPORTANT NOTE: always initialize the interactor before doing the # rendering! my_interactor.Initialize() # Step 8. Actual Rendering # Draw something on the screen (finally!) my_window.Render() # Step 9. Interaction Starts # We are done: entering the interaction loop. The user is in charge my_interactor.Start()
def Execute(self): if (self.Surface == None): self.PrintError('Error: no Surface.') if (self.Surface.GetPointData().GetArray(self.SurfaceArrayName) == None): self.PrintError('Error: no array with name specified') else: array = self.Surface.GetPointData().GetArray(self.SurfaceArrayName) surface = self.Surface extractEdges = vtk.vtkExtractEdges() extractEdges.SetInput(surface) extractEdges.Update() surfEdges = extractEdges.GetOutput() if self.Connexity == 1: for n in range (self.Iterations): for i in range (surfEdges.GetNumberOfPoints()): cells = vtk.vtkIdList() surfEdges.GetPointCells(i,cells) vval = 0 ddd = 0 d = 0 N = 0 for j in range (cells.GetNumberOfIds()): points = vtk.vtkIdList() surfEdges.GetCellPoints(cells.GetId(j),points) for k in range (points.GetNumberOfIds()): if points.GetId(k) != i: d = math.sqrt(vtk.vtkMath.Distance2BetweenPoints(surface.GetPoint(i),surface.GetPoint(points.GetId(k)))) dd = 1/d val = array.GetComponent(points.GetId(k),0)#*dd N = N+1 vval = vval + val ddd = ddd + dd val = array.GetComponent(i,0) vval = vval / (N) newval = self.Relaxation * vval + (1 - self.Relaxation) * val array.SetTuple1(i,newval) elif self.Connexity == 2: for n in range (self.Iterations): for i in range (surfEdges.GetNumberOfPoints()): cells = vtk.vtkIdList() surfEdges.GetPointCells(i,cells) pointlist = vtk.vtkIdList() vval = 0 ddd = 0 d = 0 N = 0 for j in range (cells.GetNumberOfIds()): points = vtk.vtkIdList() surfEdges.GetCellPoints(cells.GetId(j),points) for k in range (points.GetNumberOfIds()): if points.GetId(k) != i: pointlist.InsertUniqueId(points.GetId(k)) cells2 = vtk.vtkIdList() surfEdges.GetPointCells(i,cells2) for p in range (cells2.GetNumberOfIds()): points2 = vtk.vtkIdList() surfEdges.GetCellPoints(cells2.GetId(j),points2) for q in range (points2.GetNumberOfIds()): if points2.GetId(k) != i: pointlist.InsertUniqueId(points2.GetId(k)) N = pointlist.GetNumberOfIds() for j in range (pointlist.GetNumberOfIds()): d = math.sqrt(vtk.vtkMath.Distance2BetweenPoints(surface.GetPoint(i),surface.GetPoint(pointlist.GetId(j)))) dd = 1/d val = array.GetComponent(pointlist.GetId(j),0) vval = vval + val ddd = ddd + dd val = array.GetComponent(i,0) vval = vval / (N) newval = self.Relaxation * vval + (1 - self.Relaxation) * val array.SetTuple1(i,newval) else: self.PrintError ('Error: wrong connexity') self.Surface = surface
def _plotInternal(self): prepedContours = self._prepContours() tmpLevels = prepedContours["tmpLevels"] tmpIndices = prepedContours["tmpIndices"] tmpColors = prepedContours["tmpColors"] tmpOpacities = prepedContours["tmpOpacities"] style = self._gm.fillareastyle fareapixelspacing, fareapixelscale = self._patternSpacingAndScale() mappers = [] luts = [] geos = [] wholeDataMin, wholeDataMax = vcs.minmax(self._data1) plotting_dataset_bounds = self.getPlottingBounds() x1, x2, y1, y2 = plotting_dataset_bounds # We need to do the convertion thing _convert = self._gm.yaxisconvert _func = vcs.utils.axisConvertFunctions[_convert]["forward"] y1 = _func(y1) y2 = _func(y2) _convert = self._gm.xaxisconvert _func = vcs.utils.axisConvertFunctions[_convert]["forward"] x1 = _func(x1) x2 = _func(x2) _colorMap = self.getColorMap() for i, l in enumerate(tmpLevels): # Ok here we are trying to group together levels can be, a join # will happen if: next set of levels contnues where one left off # AND pattern is identical # TODO this should really just be a single polydata that is # colored by scalars: for j, color in enumerate(tmpColors[i]): mapper = vtk.vtkPolyDataMapper() lut = vtk.vtkLookupTable() th = vtk.vtkThreshold() th.ThresholdBetween(l[j], l[j + 1]) # th.SetInputConnection(self._vtkPolyDataFilter.GetOutputPort()) th.SetInputData(self._vtkDataSetFittedToViewport) geoFilter2 = vtk.vtkDataSetSurfaceFilter() geoFilter2.SetInputConnection(th.GetOutputPort()) # Make the polydata output available here for patterning later geoFilter2.Update() geos.append(geoFilter2) mapper.SetInputConnection(geoFilter2.GetOutputPort()) lut.SetNumberOfTableValues(1) r, g, b, a = self.getColorIndexOrRGBA(_colorMap, color) if style == 'solid': tmpOpacity = tmpOpacities[j] if tmpOpacity is None: tmpOpacity = a / 100. else: tmpOpacity = tmpOpacities[j] / 100. lut.SetTableValue(0, r / 100., g / 100., b / 100., tmpOpacity) else: lut.SetTableValue(0, 1., 1., 1., 0.) mapper.SetLookupTable(lut) mapper.SetScalarRange(l[j], l[j + 1]) luts.append([lut, [l[j], l[j + 1], True]]) # Store the mapper only if it's worth it? # Need to do it with the whole slab min/max for animation # purposes if not (l[j + 1] < wholeDataMin or l[j] > wholeDataMax): mappers.append(mapper) self._resultDict["vtk_backend_luts"] = luts if len(geos) > 0: self._resultDict["vtk_backend_geofilters"] = geos if self._maskedDataMapper is not None: # Note that this is different for meshfill -- others prepend. mappers.append(self._maskedDataMapper) wireColor = [0, 0, 0, 255] # Add a second mapper for wireframe meshfill: if self._gm.mesh: lineMappers = [] for polyMapper in mappers: edgeFilter = vtk.vtkExtractEdges() edgeFilter.SetInputConnection( polyMapper.GetInputConnection(0, 0)) lineMapper = vtk.vtkPolyDataMapper() lineMapper.SetInputConnection(edgeFilter.GetOutputPort(0)) lineMapper._useWireFrame = True lineMappers.append(lineMapper) mappers.extend(lineMappers) # And now we need actors to actually render this thing actors = [] vp = self._resultDict.get('ratio_autot_viewport', [ self._template.data.x1, self._template.data.x2, self._template.data.y1, self._template.data.y2 ]) cti = 0 ctj = 0 # view and interactive area view = self._context().contextView area = vtk.vtkInteractiveArea() view.GetScene().AddItem(area) adjusted_plotting_bounds = vcs2vtk.getProjectedBoundsForWorldCoords( plotting_dataset_bounds, self._gm.projection) drawAreaBounds = vcs2vtk.computeDrawAreaBounds( adjusted_plotting_bounds) [renWinWidth, renWinHeight] = self._context().renWin.GetSize() geom = vtk.vtkRecti(int(round(vp[0] * renWinWidth)), int(round(vp[2] * renWinHeight)), int(round((vp[1] - vp[0]) * renWinWidth)), int(round((vp[3] - vp[2]) * renWinHeight))) vcs2vtk.configureContextArea(area, drawAreaBounds, geom) for mapper in mappers: act = vtk.vtkActor() act.SetMapper(mapper) mapper.Update() poly = mapper.GetInput() item = None wireframe = False if hasattr(mapper, "_useWireFrame"): wireframe = True if wireframe: item = vtk.vtkPolyDataItem() item.SetPolyData(poly) colorArray = vtk.vtkUnsignedCharArray() colorArray.SetNumberOfComponents(4) for i in range(poly.GetNumberOfCells()): colorArray.InsertNextTypedTuple(wireColor) item.SetScalarMode(vtk.VTK_SCALAR_MODE_USE_CELL_DATA) item.SetMappedColors(colorArray) area.GetDrawAreaItem().AddItem(item) elif style == "solid": if self._needsCellData: attrs = poly.GetCellData() else: attrs = poly.GetPointData() data = attrs.GetScalars() deleteColors = False if data: lut = mapper.GetLookupTable() scalarRange = mapper.GetScalarRange() lut.SetRange(scalarRange) mappedColors = lut.MapScalars(data, vtk.VTK_COLOR_MODE_DEFAULT, 0) deleteColors = True else: loc = 'point' numTuples = poly.GetNumberOfPoints() if self._needsCellData: loc = 'cell' numTuples = poly.GetNumberOfCells() msg = 'WARNING: meshfill pipeline: poly does not have Scalars ' msg = msg + 'array on {0} data, using solid color'.format( loc) print(msg) color = [0, 0, 0, 255] mappedColors = vcs2vtk.generateSolidColorArray( numTuples, color) mappedColors.SetName('Colors') item = vtk.vtkPolyDataItem() item.SetPolyData(poly) if self._needsCellData: item.SetScalarMode(vtk.VTK_SCALAR_MODE_USE_CELL_DATA) else: item.SetScalarMode(vtk.VTK_SCALAR_MODE_USE_POINT_DATA) item.SetMappedColors(mappedColors) if deleteColors: mappedColors.FastDelete() area.GetDrawAreaItem().AddItem(item) # TODO See comment in boxfill. if item is not None: if mapper is self._maskedDataMapper: actors.append([ item, self._maskedDataMapper, plotting_dataset_bounds ]) else: actors.append([item, plotting_dataset_bounds]) if mapper is not self._maskedDataMapper: if not wireframe: # Since pattern creation requires a single color, assuming the # first if ctj >= len(tmpColors[cti]): ctj = 0 cti += 1 c = self.getColorIndexOrRGBA(_colorMap, tmpColors[cti][ctj]) patact = fillareautils.make_patterned_polydata( poly, fillareastyle=style, fillareaindex=tmpIndices[cti], fillareacolors=c, fillareaopacity=tmpOpacities[cti], fillareapixelspacing=fareapixelspacing, fillareapixelscale=fareapixelscale, size=self._context().renWin.GetSize(), screenGeom=self._context().renWin.GetSize()) ctj += 1 if patact is not None: actors.append([patact, plotting_dataset_bounds]) patMapper = patact.GetMapper() patMapper.Update() patPoly = patMapper.GetInput() patItem = vtk.vtkPolyDataItem() patItem.SetPolyData(patPoly) patItem.SetScalarMode( vtk.VTK_SCALAR_MODE_USE_CELL_DATA) colorArray = patPoly.GetCellData().GetArray('Colors') patItem.SetMappedColors(colorArray) area.GetDrawAreaItem().AddItem(patItem) actors.append([patItem, plotting_dataset_bounds]) z, t = self.getZandT() self._resultDict["vtk_backend_actors"] = actors kwargs = { "vtk_backend_grid": self._vtkDataSet, "dataset_bounds": self._vtkDataSetBounds, "plotting_dataset_bounds": plotting_dataset_bounds, "vtk_dataset_bounds_no_mask": self._vtkDataSetBoundsNoMask, "vtk_backend_geo": self._vtkGeoTransform, "vtk_backend_draw_area_bounds": drawAreaBounds, "vtk_backend_viewport_scale": [self._context_xScale, self._context_yScale] } if ("ratio_autot_viewport" in self._resultDict): kwargs["ratio_autot_viewport"] = vp self._resultDict.update(self._context().renderTemplate( self._template, self._data1, self._gm, t, z, X=numpy.arange(min(x1, x2), max(x1, x2) * 1.1, abs(x2 - x1) / 10.), Y=numpy.arange(min(y1, y2), max(y1, y2) * 1.1, abs(y2 - y1) / 10.), **kwargs)) legend = getattr(self._gm, "legend", None) if self._gm.ext_1: if isinstance(self._contourLevels[0], list): if numpy.less(abs(self._contourLevels[0][0]), 1.e20): # Ok we need to add the ext levels self._contourLevels.insert( 0, [-1.e20, self._contourLevels[0][0]]) else: if numpy.less(abs(self._contourLevels[0]), 1.e20): # need to add an ext self._contourLevels.insert(0, -1.e20) if self._gm.ext_2: if isinstance(self._contourLevels[-1], list): if numpy.less(abs(self._contourLevels[-1][1]), 1.e20): # need ext self._contourLevels.append( [self._contourLevels[-1][1], 1.e20]) else: if numpy.less(abs(self._contourLevels[-1]), 1.e20): # need exts self._contourLevels.append(1.e20) patternArgs = {} patternArgs['style'] = self._gm.fillareastyle patternArgs['index'] = self._gm.fillareaindices if patternArgs['index'] is None: patternArgs['index'] = [ 1, ] # Compensate for the different viewport size of the colorbar patternArgs['opacity'] = self._gm.fillareaopacity patternArgs['pixelspacing'] = [ int(fareapixelspacing[0] / (vp[1] - vp[0])), int(fareapixelspacing[1] / (vp[3] - vp[2])) ] patternArgs['pixelscale'] = fareapixelscale / (vp[1] - vp[0]) self._resultDict.update(self._context().renderColorBar( self._template, self._contourLevels, self._contourColors, legend, self.getColorMap(), **patternArgs)) projection = vcs.elements["projection"][self._gm.projection] kwargs['xaxisconvert'] = self._gm.xaxisconvert kwargs['yaxisconvert'] = self._gm.yaxisconvert self._context().plotContinents( self._plot_kargs.get("continents", self._useContinents), plotting_dataset_bounds, projection, self._dataWrapModulo, vp, self._template.data.priority, **kwargs)
def main(filename): print("Loading", filename) reader = vtk.vtkUnstructuredGridReader() reader.SetFileName(filename) edges = vtk.vtkExtractEdges() edges.SetInputConnection(reader.GetOutputPort()) tubes = vtk.vtkTubeFilter() tubes.SetInputConnection(edges.GetOutputPort()) tubes.SetRadius(0.0625) tubes.SetVaryRadiusToVaryRadiusOff() tubes.SetNumberOfSides(32) tubesMapper = vtk.vtkPolyDataMapper() tubesMapper.SetInputConnection(tubes.GetOutputPort()) tubesMapper.SetScalarRange(0.0, 26.0) tubesActor = vtk.vtkActor() tubesActor.SetMapper(tubesMapper) gradients = vtk.vtkGradientFilter() gradients.SetInputConnection(reader.GetOutputPort()) vectors = vtk.vtkAssignAttribute() vectors.SetInputConnection(gradients.GetOutputPort()) vectors.Assign("Gradients", vtk.vtkDataSetAttributes.VECTORS, \ vtk.vtkAssignAttribute.POINT_DATA) arrow = vtk.vtkArrowSource() glyphs = vtk.vtkGlyph3D() glyphs.SetInputConnection(0, vectors.GetOutputPort()) glyphs.SetInputConnection(1, arrow.GetOutputPort()) glyphs.ScalingOn() glyphs.SetScaleModeToScaleByVector() glyphs.SetScaleFactor(0.25) glyphs.OrientOn() glyphs.ClampingOff() glyphs.SetVectorModeToUseVector() glyphs.SetIndexModeToOff() glyphMapper = vtk.vtkPolyDataMapper() glyphMapper.SetInputConnection(glyphs.GetOutputPort()) glyphMapper.ScalarVisibilityOff() glyphActor = vtk.vtkActor() glyphActor.SetMapper(glyphMapper) renderer = vtk.vtkRenderer() renderer.AddActor(tubesActor) renderer.AddActor(glyphActor) renderer.SetBackground(0.328125, 0.347656, 0.425781) renwin = vtk.vtkRenderWindow() renwin.AddRenderer(renderer) renwin.SetSize(350, 500) renderer.ResetCamera() camera = renderer.GetActiveCamera() camera.Elevation(-80.0) camera.OrthogonalizeViewUp() camera.Azimuth(135.0) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renwin) iren.Initialize() iren.Start() return 1
# Append the quadratic cells together appendF = vtk.vtkAppendFilter() appendF.AddInputData(BQuadGrid) appendF.AddInputData(QLQuadGrid) appendF.AddInputData(QLWedgeGrid) appendF.AddInputData(aTriGrid) appendF.AddInputData(aQuadGrid) appendF.AddInputData(aTetGrid) appendF.AddInputData(aHexGrid) appendF.AddInputData(TQHexGrid) appendF.AddInputData(BQHexGrid) appendF.AddInputData(aWedgeGrid) appendF.AddInputData(aPyraGrid) appendF.AddInputData(BQWedgeGrid) # Extract the edges extract = vtk.vtkExtractEdges() extract.SetInputConnection(appendF.GetOutputPort()) shrink = vtk.vtkShrinkPolyData() shrink.SetInputConnection(extract.GetOutputPort()) shrink.SetShrinkFactor(0.90) aMapper = vtk.vtkDataSetMapper() aMapper.SetInputConnection(shrink.GetOutputPort()) #aMapper ScalarVisibilityOff aActor = vtk.vtkActor() aActor.SetMapper(aMapper) aActor.GetProperty().SetRepresentationToWireframe() # Create the rendering related stuff. ren1 = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren1) iren = vtk.vtkRenderWindowInteractor()
Ids.InsertNextId(1) Ids.InsertNextId(2) Ids.InsertNextId(3) Ids.InsertNextId(4) Grid = vtk.vtkUnstructuredGrid() Grid.Allocate(10,10) Grid.InsertNextCell(14,Ids) Grid.SetPoints(Points) Grid.GetPointData().SetScalars(Scalars) #Clip the pyramid clipper = vtk.vtkClipDataSet() clipper.SetInputData(Grid) clipper.SetValue(0.5) # build tubes for the triangle edges # pyrEdges = vtk.vtkExtractEdges() pyrEdges.SetInputConnection(clipper.GetOutputPort()) pyrEdgeTubes = vtk.vtkTubeFilter() pyrEdgeTubes.SetInputConnection(pyrEdges.GetOutputPort()) pyrEdgeTubes.SetRadius(.005) pyrEdgeTubes.SetNumberOfSides(6) pyrEdgeMapper = vtk.vtkPolyDataMapper() pyrEdgeMapper.SetInputConnection(pyrEdgeTubes.GetOutputPort()) pyrEdgeMapper.ScalarVisibilityOff() pyrEdgeActor = vtk.vtkActor() pyrEdgeActor.SetMapper(pyrEdgeMapper) pyrEdgeActor.GetProperty().SetDiffuseColor(lamp_black) pyrEdgeActor.GetProperty().SetSpecular(.4) pyrEdgeActor.GetProperty().SetSpecularPower(10) #shrink the triangles so we can see each one aShrinker = vtk.vtkShrinkFilter()
def serveVTKGeoJSON(self, datasetString): ''' Deliver a geojson encoded serialized vtkpolydata file and render it over the canonical cpipe scene. ''' if vtkOK == False: return """<html><head></head><body>VTK python bindings are not loadable, be sure VTK is installed on the server and its PATHS are set appropriately.</body><html>""" ss = vtk.vtkNetCDFCFReader() #get test data ss.SphericalCoordinatesOff() ss.SetOutputTypeToImage() datadir = cherrypy.request.app.config['/data']['tools.staticdir.dir'] datadir = os.path.join(datadir, 'assets') datafile = os.path.join(datadir, 'clt.nc') ss.SetFileName(datafile) sf = vtk.vtkDataSetSurfaceFilter() #convert to polydata sf.SetInputConnection(ss.GetOutputPort()) cf = vtk.vtkContourFilter() #add some attributes cf.SetInputConnection(sf.GetOutputPort()) cf.SetInputArrayToProcess(0,0,0,"vtkDataObject::FIELD_ASSOCIATION_POINTS", "clt") cf.SetNumberOfContours(10) sf.Update() drange = sf.GetOutput().GetPointData().GetArray(0).GetRange() for x in range(0,10): cf.SetValue(x,x*0.1*(drange[1]-drange[0])+drange[0]) cf.ComputeScalarsOn() ef = vtk.vtkExtractEdges() #make lines to test ef.SetInputConnection(sf.GetOutputPort()) gf = vtk.vtkGlyph3D() #make verts to test pts = vtk.vtkPoints() pts.InsertNextPoint(0,0,0) verts = vtk.vtkCellArray() avert = vtk.vtkVertex() avert.GetPointIds().SetId(0, 0) verts.InsertNextCell(avert) onevertglyph = vtk.vtkPolyData() onevertglyph.SetPoints(pts) onevertglyph.SetVerts(verts) gf.SetSourceData(onevertglyph) gf.SetInputConnection(sf.GetOutputPort()) if datasetString == "points": toshow = gf elif datasetString == "lines": toshow = ef elif datasetString == "contour": toshow = cf else: toshow = sf gw = vtk.vtkGeoJSONWriter() gw.SetInputConnection(toshow.GetOutputPort()) gw.SetScalarFormat(2); if True: gw.SetFileName("/Source/CPIPES/buildogs/deploy/dataset.gj") gw.Write() f = file("/Source/CPIPES/buildogs/deploy/dataset.gj") gj = str(f.readlines()) else: gw.WriteToOutputStringOn() gw.Write() gj = "['"+str(gw.RegisterAndGetOutputString()).replace('\n','')+"']" res = (""" <html> <head> <script type="text/javascript" src="/common/js/gl-matrix.js"></script> <script type="text/javascript" src="/lib/geoweb.min.js"></script> <script type="text/javascript" src="//ajax.googleapis.com/ajax/libs/jquery/1.9.0/jquery.min.js"></script> <script type="text/javascript"> function makedata() { var datasetString = %(gjfile)s.join('\\n'); var data = new ogs.vgl.geojsonReader().getPrimitives(datasetString); var geoms = data.geoms; var mapper = new ogs.vgl.mapper(); mapper.setGeometryData(geoms[0]); """ + self.gjShader + """ var actor = new ogs.vgl.actor(); actor.setMapper(mapper); actor.setMaterial(mat); return actor; } </script> <script type="text/javascript"> function main() { var mapOptions = { zoom : 1, center : ogs.geo.latlng(0.0, 0.0), source : '/data/assets/land_shallow_topo_2048.png' }; var myMap = ogs.geo.map(document.getElementById("glcanvas"), mapOptions); var planeLayer = ogs.geo.featureLayer({ "opacity" : 1, "showAttribution" : 1, "visible" : 1 }, makedata() ); myMap.addLayer(planeLayer); } </script> <link rel="stylesheet" href="http://code.jquery.com/ui/1.10.1/themes/base/jquery-ui.css" /> <script src="http://code.jquery.com/jquery-1.9.1.js"></script> <script src="http://code.jquery.com/ui/1.10.1/jquery-ui.js"></script> </head> <body onload="main()"> <canvas id="glcanvas" width="800" height="600"></canvas> </body> </html> """) % {'gjfile' :gj} return res
from __future__ import print_function import vtk, os, sys from vtk.test import Testing ss = vtk.vtkSphereSource() #make mesh to test with af = vtk.vtkElevationFilter() #add some attributes af.SetInputConnection(ss.GetOutputPort()) ef = vtk.vtkExtractEdges() #make lines to test ef.SetInputConnection(af.GetOutputPort()) gf = vtk.vtkGlyph3D() #make verts to test pts = vtk.vtkPoints() pts.InsertNextPoint(0, 0, 0) verts = vtk.vtkCellArray() avert = vtk.vtkVertex() avert.GetPointIds().SetId(0, 0) verts.InsertNextCell(avert) onevertglyph = vtk.vtkPolyData() onevertglyph.SetPoints(pts) onevertglyph.SetVerts(verts) gf.SetSourceData(onevertglyph) gf.SetInputConnection(af.GetOutputPort()) testwrites = ["points", "lines", "mesh"] failed = False for datasetString in testwrites: if datasetString == "points": toshow = gf
Ids.InsertNextId(7) Grid = vtk.vtkUnstructuredGrid() Grid.Allocate(10, 10) Grid.InsertNextCell(12, Ids) Grid.SetPoints(Points) Grid.GetPointData().SetScalars(Scalars) # Find the triangles that lie along the 0.5 contour in this cube. Marching = vtk.vtkContourFilter() Marching.SetInput(Grid) Marching.SetValue(0, 0.5) Marching.Update() # Extract the edges of the triangles just found. triangleEdges = vtk.vtkExtractEdges() triangleEdges.SetInputConnection(Marching.GetOutputPort()) # Draw the edges as tubes instead of lines. Also create the associated # mapper and actor to display the tubes. triangleEdgeTubes = vtk.vtkTubeFilter() triangleEdgeTubes.SetInputConnection(triangleEdges.GetOutputPort()) triangleEdgeTubes.SetRadius(.005) triangleEdgeTubes.SetNumberOfSides(6) triangleEdgeTubes.UseDefaultNormalOn() triangleEdgeTubes.SetDefaultNormal(.577, .577, .577) triangleEdgeMapper = vtk.vtkPolyDataMapper() triangleEdgeMapper.SetInputConnection(triangleEdgeTubes.GetOutputPort()) triangleEdgeMapper.ScalarVisibilityOff() triangleEdgeActor = vtk.vtkActor() triangleEdgeActor.SetMapper(triangleEdgeMapper) triangleEdgeActor.GetProperty().SetDiffuseColor(lamp_black)
def render(self, pointsData, scalarsArray, radiusArray, nspecies, colouringOptions, atomScaleFactor, lut): """ Render the given antisites (wire frame). """ self._logger.debug("Rendering antisites: colour by '%s'", colouringOptions.colourBy) # points points = vtk.vtkPoints() points.SetData(pointsData.getVTK()) # poly data polydata = vtk.vtkPolyData() polydata.SetPoints(points) polydata.GetPointData().AddArray(scalarsArray.getVTK()) polydata.GetPointData().SetScalars(radiusArray.getVTK()) # source cubeSource = vtk.vtkCubeSource() edges = vtk.vtkExtractEdges() edges.SetInputConnection(cubeSource.GetOutputPort()) glyphSource = vtk.vtkTubeFilter() glyphSource.SetInputConnection(edges.GetOutputPort()) glyphSource.SetRadius(0.05) glyphSource.SetVaryRadius(0) glyphSource.SetNumberOfSides(5) glyphSource.UseDefaultNormalOn() glyphSource.SetDefaultNormal(.577, .577, .577) # glyph glyph = vtk.vtkGlyph3D() if vtk.vtkVersion.GetVTKMajorVersion() <= 5: glyph.SetSource(glyphSource.GetOutput()) glyph.SetInput(polydata) else: glyph.SetSourceConnection(glyphSource.GetOutputPort()) glyph.SetInputData(polydata) glyph.SetScaleFactor(atomScaleFactor * 2.0) glyph.SetScaleModeToScaleByScalar() glyph.ClampingOff() # mapper mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(glyph.GetOutputPort()) mapper.SetLookupTable(lut) mapper.SetScalarModeToUsePointFieldData() mapper.SelectColorArray("colours") utils.setMapperScalarRange(mapper, colouringOptions, nspecies) # actor actor = vtk.vtkActor() actor.SetMapper(mapper) # store attributes self._actor = utils.ActorObject(actor) self._data["Points"] = pointsData self._data["Scalars"] = scalarsArray self._data["Radius"] = radiusArray self._data["LUT"] = lut self._data["Scale factor"] = atomScaleFactor
# is also the input to the Delaunay filter. The points of the # vtkPolyData are used to generate the triangulation; the polygons are # used to create a constraint region. The polygons are very carefully # created and ordered in the right direction to indicate inside and # outside of the polygon. delny = vtk.vtkDelaunay2D() delny.SetInputData(polyData) delny.SetSourceData(polyData) mapMesh = vtk.vtkPolyDataMapper() mapMesh.SetInputConnection(delny.GetOutputPort()) meshActor = vtk.vtkActor() meshActor.SetMapper(mapMesh) # Now we just pretty the mesh up with tubed edges and balls at the # vertices. extract = vtk.vtkExtractEdges() extract.SetInputConnection(delny.GetOutputPort()) tubes = vtk.vtkTubeFilter() tubes.SetInputConnection(extract.GetOutputPort()) tubes.SetRadius(0.1) tubes.SetNumberOfSides(6) mapEdges = vtk.vtkPolyDataMapper() mapEdges.SetInputConnection(tubes.GetOutputPort()) edgeActor = vtk.vtkActor() edgeActor.SetMapper(mapEdges) edgeActor.GetProperty().SetColor(peacock) edgeActor.GetProperty().SetSpecularColor(1, 1, 1) edgeActor.GetProperty().SetSpecular(0.3) edgeActor.GetProperty().SetSpecularPower(20) edgeActor.GetProperty().SetAmbient(0.2) edgeActor.GetProperty().SetDiffuse(0.8)
subdiv.SetNumberOfSubdivisions(4) if vtk.vtkVersion.GetVTKMajorVersion() >= 6: subdiv.SetInputData(surface) else: subdiv.SetInput(surface) surfaceMapper = vtk.vtkPolyDataMapper() surfaceMapper.SetInputConnection(subdiv.GetOutputPort()) surfaceMapper.SetScalarRange(0, 24) surfaceMapper.SetLookupTable(lut) surfaceActor = vtk.vtkActor() surfaceActor.SetMapper(surfaceMapper) ren.AddActor(surfaceActor) draw_edges = False if draw_edges: lines = vtk.vtkExtractEdges() if vtk.vtkVersion.GetVTKMajorVersion() >= 6: lines.SetInputData(edges) else: lines.SetInput(edges) tube = vtk.vtkTubeFilter() tube.SetInputConnection(lines.GetOutputPort()) tube.SetRadius(0.005) tube.SetNumberOfSides(20) sphere = vtk.vtkSphereSource() sphere.SetRadius(0.005) sphere.SetPhiResolution(20) sphere.SetThetaResolution(20) vertices = vtk.vtkGlyph3D() if vtk.vtkVersion.GetVTKMajorVersion() >= 6:
def populateTopologyDictionary(self): # Create vtk objects that will be used to clean the geometries firstValue = { } # This will be used for checking consistent, inconsistent topologies for nodeName in self.testCaseDict.keys(): # Topology table is a dictionary of dictionaries. self.topologyDict[nodeName] = {} self.polyDataDict[nodeName] = {} for segmentNum in range(self.labelRangeInCohort[0], self.labelRangeInCohort[1] + 1): # 0 label is assumed to be the background. if segmentNum == 0: continue segmentId = str(segmentNum) polydata = self.segmentationDict[ nodeName].GetClosedSurfaceRepresentation(segmentId) if polydata == None: print 'Ignoring segment id ' + segmentId + ' for case: ' + nodeName continue polydataCleaner = vtk.vtkCleanPolyData() connectivityFilter = vtk.vtkPolyDataConnectivityFilter() extractEdgeFilter = vtk.vtkExtractEdges() # clean up polydata polydataCleaner.SetInputData(polydata) polydataCleaner.Update() cleanData = polydataCleaner.GetOutput() # Get the largest connected component connectivityFilter.SetInputData(cleanData) connectivityFilter.SetExtractionModeToLargestRegion() connectivityFilter.SetScalarConnectivity(0) connectivityFilter.Update() largestComponent = connectivityFilter.GetOutput() # Clean the largest component to get rid of spurious points polydataCleaner.SetInputData(largestComponent) polydataCleaner.Update() cleanData = polydataCleaner.GetOutput() # run extract edge filter extractEdgeFilter.SetInputData(cleanData) extractEdgeFilter.Update() edges = extractEdgeFilter.GetOutput() # calculate the numbers topologyNumber = cleanData.GetNumberOfPoints() - edges.GetNumberOfLines()\ + cleanData.GetNumberOfPolys() self.topologyDict[nodeName][segmentNum] = topologyNumber if self.saveCleanData: self.polyDataDict[nodeName][segmentNum] = cleanData else: self.polyDataDict[nodeName][segmentNum] = polydata del edges del largestComponent del cleanData # Check for consistency in the cohort for this segment label if segmentNum not in self.consistentTopologyDict.keys(): self.consistentTopologyDict[segmentNum] = 'Consistent' firstValue[segmentNum] = self.topologyDict[nodeName][ segmentNum] # print 'Adding segment num ' + segmentId + ' with top number: ' + str(topologyNumber) + ' For consistencies' elif firstValue[segmentNum] != self.topologyDict[nodeName][segmentNum] \ and self.consistentTopologyDict[segmentNum] is 'Consistent': self.consistentTopologyDict[segmentNum] = 'InConsistent'
Ids.InsertNextId(1) Ids.InsertNextId(2) Ids.InsertNextId(3) Ids.InsertNextId(4) Grid = vtk.vtkUnstructuredGrid() Grid.Allocate(10, 10) Grid.InsertNextCell(14, Ids) Grid.SetPoints(Points) Grid.GetPointData().SetScalars(Scalars) #Clip the pyramid clipper = vtk.vtkClipDataSet() clipper.SetInputData(Grid) clipper.SetValue(0.5) # build tubes for the triangle edges # pyrEdges = vtk.vtkExtractEdges() pyrEdges.SetInputConnection(clipper.GetOutputPort()) pyrEdgeTubes = vtk.vtkTubeFilter() pyrEdgeTubes.SetInputConnection(pyrEdges.GetOutputPort()) pyrEdgeTubes.SetRadius(.005) pyrEdgeTubes.SetNumberOfSides(6) pyrEdgeMapper = vtk.vtkPolyDataMapper() pyrEdgeMapper.SetInputConnection(pyrEdgeTubes.GetOutputPort()) pyrEdgeMapper.ScalarVisibilityOff() pyrEdgeActor = vtk.vtkActor() pyrEdgeActor.SetMapper(pyrEdgeMapper) pyrEdgeActor.GetProperty().SetDiffuseColor(lamp_black) pyrEdgeActor.GetProperty().SetSpecular(.4) pyrEdgeActor.GetProperty().SetSpecularPower(10) #shrink the triangles so we can see each one aShrinker = vtk.vtkShrinkFilter()
def test_mesh_elements(): s = _generate_sphere() ee = vtk.vtkExtractEdges() ee.SetInputData(s.VTKObject) ee.Update() ee = wrap_vtk(ee.GetOutput()) n_edges = ee.n_cells assert np.all(me.get_points(s) == s.Points) assert np.all(me.get_cells(s) == s.get_cells2D()) assert me.get_extent(s).shape == (3, ) pc = me.get_point2cell_connectivity(s) assert pc.shape == (s.n_points, s.n_cells) assert pc.dtype == np.uint8 assert np.all(pc.sum(axis=0) == 3) cp = me.get_cell2point_connectivity(s) assert pc.dtype == np.uint8 assert (pc - cp.T).nnz == 0 adj = me.get_immediate_adjacency(s) assert adj.shape == (s.n_points, s.n_points) assert adj.dtype == np.uint8 assert adj.nnz == (2 * n_edges + s.n_points) adj2 = me.get_immediate_adjacency(s, include_self=False) assert adj2.shape == (s.n_points, s.n_points) assert adj2.dtype == np.uint8 assert adj2.nnz == (2 * n_edges) radj = me.get_ring_adjacency(s) assert radj.dtype == np.uint8 assert (adj - radj).nnz == 0 radj2 = me.get_ring_adjacency(s, include_self=False) assert radj2.dtype == np.uint8 assert (adj2 - radj2).nnz == 0 radj3 = me.get_ring_adjacency(s, n_ring=2, include_self=False) assert radj3.dtype == np.uint8 assert (radj3 - adj2).nnz > 0 d = me.get_immediate_distance(s) assert d.shape == (s.n_points, s.n_points) assert d.dtype == np.float assert d.nnz == adj2.nnz d2 = me.get_immediate_distance(s, metric='sqeuclidean') d_sq = d.copy() d_sq.data **= 2 assert np.allclose(d_sq.A, d2.A) rd = me.get_ring_distance(s) assert rd.dtype == np.float assert np.allclose(d.A, rd.A) rd2 = me.get_ring_distance(s, n_ring=2) assert (rd2 - d).nnz > 0 assert me.get_cell_neighbors(s).shape == (s.n_cells, s.n_cells) assert me.get_edges(s).shape == (n_edges, 2) assert me.get_edge_length(s).shape == (n_edges, ) assert me.get_boundary_points(s).size == 0 assert me.get_boundary_edges(s).size == 0 assert me.get_boundary_cells(s).size == 0