def __init__(self, parent, visualizer, **kws): """ Initialization """ VisualizationModule.__init__(self, parent, visualizer, **kws) self.descs = {"TrackFile": "Tracks file", #"AllTracks": "Show all tracks", \ "MinLength": "Min. length of track (# of timepoints)", "SphereRadius": "Sphere radius", "TubeRadius": "Tube radius", "SameStartingPoint": "Visualize tracks starting from same point"} self.showTracks = [] self.lineMapper = vtk.vtkPolyDataMapper() self.sphereMapper = vtk.vtkPolyDataMapper() self.firstMapper = vtk.vtkPolyDataMapper() self.lastMapper = vtk.vtkPolyDataMapper() self.currentMapper = vtk.vtkPolyDataMapper() self.actors = [] self.renderer = self.parent.getRenderer() #iactor = self.wxrenwin.GetRenderWindow().GetInteractor() lib.messenger.connect(None, "visualize_tracks", self.onVisualizeTracks) self.filterDesc = "Visualize created motion tracks"
def _MakeActors(self): actors = [] # lines for i in range(3): mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(self._Cutters[i].GetOutputPort()) actor = self._NewActor() actor.SetProperty(self._Properties[i]) actor.SetMapper(mapper) actor.PickableOff() actors.append(actor) # use index to track actors in different renderers self._LineActorsIndex = (0, 1, 2) # cones for i in range(6): mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(self._Cones[i].GetOutputPort()) actor = self._NewActor() actor.SetProperty(self._ConeProperties[i / 2]) actor.SetMapper(mapper) actor.PickableOff() actors.append(actor) self._ConeActorsIndex = (3, 4, 5, 6, 7, 8) return actors
def addPoints(self, points, color, thick=False, thickness=_DEFAULT_POINT_THICKNESS): vtkPoints = vtk.vtkPoints() for point in points: vtkPoints.InsertNextPoint(point[0], point[1], point[2]) pointsPolyData = vtk.vtkPolyData() pointsPolyData.SetPoints(vtkPoints) if thick: sphereSource = vtk.vtkSphereSource() sphereSource.SetRadius(thickness) glyph3D = vtk.vtkGlyph3D() glyph3D.SetSourceConnection(sphereSource.GetOutputPort()) glyph3D.SetInputData(pointsPolyData) glyph3D.Update() mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(glyph3D.GetOutputPort()) else: vertexFilter = vtk.vtkVertexGlyphFilter() vertexFilter.SetInputData(pointsPolyData) vertexFilter.Update() mapper = vtk.vtkPolyDataMapper() mapper.SetInputData(vertexFilter.GetOutput()) actor = vtk.vtkActor() actor.SetMapper(mapper) actor.GetProperty().SetColor(color) self._rendererScene.AddActor(actor)
def _MakeActors(self): actors = [] # 4 corners for i in range(4): mapper = vtk.vtkPolyDataMapper() mapper.SetInput(self._Corners[i].GetOutput()) actor = self._NewActor() actor.SetProperty(self._CornerProperty) actor.SetMapper(mapper) actors.append(actor) # center mapper = vtk.vtkPolyDataMapper() mapper.SetInput(self._Center.GetOutput()) actor = self._NewActor() actor.SetProperty(self._CenterProperty) actor.SetMapper(mapper) actors.append(actor) # rectangle roi mapper = vtk.vtkPolyDataMapper() mapper.SetInput(self._ROI.GetOutput()) actor = self._NewActor() actor.SetProperty(self._ROIProperty) actor.SetMapper(mapper) actor.PickableOff() actors.append(actor) return actors
def __init__(self): # Central dot self.dot = vtk.vtkSphereSource() self.dot.SetThetaResolution(20) self.dot.SetRadius(.5) self.dotMapper = vtk.vtkPolyDataMapper() self.dotMapper.SetInputConnection(self.dot.GetOutputPort()) self.dotActor = vtk.vtkActor() self.dotActor.SetMapper(self.dotMapper) # Circular halo around dot self.halo = vtk.vtkSphereSource() self.halo.SetThetaResolution(20) self.halo.SetRadius(2) self.haloMapper = vtk.vtkPolyDataMapper() self.haloMapper.SetInputConnection(self.halo.GetOutputPort()) self.haloActor = vtk.vtkActor() self.haloActor.SetMapper(self.haloMapper) self.dotActor.GetProperty().SetColor(red) self.haloActor.GetProperty().SetColor(white) self.haloActor.GetProperty().SetOpacity(0.1) self.haloActor.GetProperty().SetSpecular(0.6) self.actor = vtk.vtkAssembly() self.actor.AddPart(self.dotActor) self.actor.AddPart(self.haloActor)
def plotContinents(self,x1,x2,y1,y2,projection,wrap,tmpl): contData = vcs2vtk.prepContinents(self.canvas._continents) contMapper = vtk.vtkPolyDataMapper() contMapper.SetInputData(contData) contActor = vtk.vtkActor() contActor.SetMapper(contMapper) contActor.GetProperty().SetColor(0.,0.,0.) contActor = vcs2vtk.doWrap(contActor,[x1,x2,y1,y2],wrap) if projection.type!="linear": contData=contActor.GetMapper().GetInput() cpts = contData.GetPoints() geo, gcpts = vcs2vtk.project(cpts,projection,[x1,x2,y1,y2]) contData.SetPoints(gcpts) contMapper = vtk.vtkPolyDataMapper() contMapper.SetInputData(contData) contActor = vtk.vtkActor() contActor.SetMapper(contMapper) contActor.GetProperty().SetColor(0.,0.,0.) else: geo=None ren = vtk.vtkRenderer() self.renWin.AddRenderer(ren) self.setLayer(ren,tmpl.data.priority) vcs2vtk.fitToViewport(contActor,ren,[tmpl.data.x1,tmpl.data.x2,tmpl.data.y1,tmpl.data.y2],wc=[x1,x2,y1,y2],geo=geo) if tmpl.data.priority!=0: ren.AddActor(contActor)
def test(points, springs1, springs2): app = QApplication(sys.argv) window = Viewer3D.SimpleView() polydata1 = GeneratePolydata.generateLinePolydata(points, springs1) polydata2 = GeneratePolydata.generateLinePolydata(points, springs2) mapper1 = vtk.vtkPolyDataMapper() mapper1.SetInputData(polydata1) actor1 = vtk.vtkActor() actor1.SetMapper(mapper1) mapper2 = vtk.vtkPolyDataMapper() mapper2.SetInputData(polydata2) actor2 = vtk.vtkActor() actor2.SetMapper(mapper2) actor1.GetProperty().SetColor(1,0,0) actor2.GetProperty().SetColor(0,1,0.5) window.ren.AddActor(actor1) window.ren.AddActor(actor2) window.start(app) return
def __init__(self, renderer): Visualizer.__init__(self) assert isinstance(renderer, vtk.vtkRenderer) self.ren = renderer # -------- add the beam ---- # geometry self.beam = vtk.vtkCubeSource() self.beam.SetXLength(st.visBeamLength) self.beam.SetYLength(st.visBeamWidth) self.beam.SetZLength(st.visBeamDepth) # mapper self.beamMapper = vtk.vtkPolyDataMapper() self.beamMapper.SetInputConnection(self.beam.GetOutputPort()) # actor self.beamActor = vtk.vtkLODActor() self.beamActor.SetMapper(self.beamMapper) # make it look nice self.beamProp = self.beamActor.GetProperty() self.beamProp.SetColor(101 / 255, 123 / 255, 131 / 255) self.ren.AddActor(self.beamActor) # -------- add the ball ---- # geometry self.ball = vtk.vtkSphereSource() self.ball.SetRadius(st.visR) self.ball.SetThetaResolution(20) self.ball.SetPhiResolution(20) # mapper self.ballMapper = vtk.vtkPolyDataMapper() self.ballMapper.SetInputConnection(self.ball.GetOutputPort()) # actor self.ballActor = vtk.vtkLODActor() self.ballActor.SetMapper(self.ballMapper) # make it look nice self.ballProp = self.ballActor.GetProperty() self.ballProp.SetColor(255 / 255, 255 / 255, 0) self.ballProp.SetAmbient(0.2) self.ballProp.SetDiffuse(0.8) self.ballProp.SetSpecular(0.5) self.ballProp.SetSpecularPower(0.5) self.ren.AddActor(self.ballActor) # add background self.ren.GradientBackgroundOn() self.ren.SetBackground(228 / 255, 232 / 255, 213 / 255) self.ren.SetBackground2(38 / 255, 139 / 255, 210 / 255) # get everybody into the frame self.ren.ResetCamera() self.ren.GetActiveCamera().Zoom(1.7)
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 render_image(pointset): delaunay = vtk.vtkDelaunay2D() delaunay.SetTolerance(0.001) delaunay.SetAlpha(18) delaunay.SetInput(pointset); delaunay.Update(); meshMapper = vtk.vtkPolyDataMapper() meshMapper.SetInput(delaunay.GetOutput()) meshMapper.SetScalarRange(0,255) meshActor = vtk.vtkActor() meshActor.SetMapper(meshMapper) boundaryMapper = vtk.vtkPolyDataMapper() boundaryMapper.SetInput(delaunay.GetOutput()) boundaryActor = vtk.vtkActor() boundaryActor.SetMapper(boundaryMapper); boundaryActor.GetProperty().SetColor(0,0.55,0); renderer = vtk.vtkRenderer() renderWindow = vtk.vtkRenderWindow() renderWindow.AddRenderer(renderer) renderWindowInteractor = vtk.vtkRenderWindowInteractor() renderWindowInteractor.SetRenderWindow(renderWindow) renderer.AddActor(meshActor) renderer.AddActor(boundaryActor) renderer.SetBackground(.5, .5, .5) renderWindow.SetSize(600, 600) renderWindow.Render() renderWindowInteractor.Start()
def __init__(self, reader): self.reader = reader sg = self.src_glyph = vtk.vtkSphereSource() sg.SetRadius(0.5) sg.SetCenter(0.5, 0.0, 0.0) g = self.glyph = vtk.vtkTensorGlyph() g.SetInputConnection(self.reader.GetOutputPort()) g.SetSource(self.src_glyph.GetOutput()) g.SetScaleFactor(0.25) # The normals are needed to generate the right colors and if # not used some of the glyphs are black. self.normals = vtk.vtkPolyDataNormals() self.normals.SetInputConnection(g.GetOutputPort()) self.map = vtk.vtkPolyDataMapper() self.map.SetInputConnection(self.normals.GetOutputPort()) self.act = vtk.vtkActor() self.act.SetMapper(self.map) # An outline. self.of = vtk.vtkOutlineFilter() self.of.SetInputConnection(self.reader.GetOutputPort()) self.out_map = vtk.vtkPolyDataMapper() self.out_map.SetInputConnection(self.of.GetOutputPort()) self.out_act = vtk.vtkActor() self.out_act.SetMapper(self.out_map)
def update_viewer(self, event, *args): MarkerWindowInteractor.update_viewer(self, event, *args) if event=='color marker': marker, color = args marker.set_color(color) elif event=='label marker': marker, label = args marker.set_label(label) if shared.debug: print "Create VTK-Text", marker.get_label() text = vtk.vtkVectorText() text.SetText(marker.get_label()) textMapper = vtk.vtkPolyDataMapper() textMapper.SetInput(text.GetOutput()) textActor = self.textActors[marker] textActor.SetMapper(textMapper) elif event=='move marker': marker, center = args marker.set_center(center) #update the select boxes and text actor textActor = self.textActors[marker] size = marker.get_size() textActor.SetScale(size, size, size) x,y,z = marker.get_center() textActor.SetPosition(x+size, y+size, z+size) if self.boxes.has_key(marker): selectActor = self.boxes[marker] boxSource = vtk.vtkCubeSource() boxSource.SetBounds(marker.GetBounds()) mapper = vtk.vtkPolyDataMapper() mapper.SetInput(boxSource.GetOutput()) selectActor.SetMapper(mapper) elif event=='labels on': actors = self.textActors.values() for actor in actors: actor.VisibilityOn() elif event=='labels off': actors = self.textActors.values() for actor in actors: actor.VisibilityOff() #elif event=='select marker': # marker = args[0] # actor = create_box_actor_around_marker(marker) # if shared.debug: print "PlaneWidgetsXYZ.update_viewer(): self.renderer.AddActor(actor)" # self.renderer.AddActor(actor) # self.boxes[marker] = actor #elif event=='unselect marker': # marker = args[0] # actor = self.boxes[marker] # print "pwxyz: u m", repr(marker), repr(actor) # self.renderer.RemoveActor(actor) # del self.boxes[marker] elif event=="set axes directions": self.add_axes_labels() EventHandler().notify('observers update plane') self.Render()
def add_edge(self, start, end, colour=Colours.BASE0): """Appends an edge to the edges list.""" # Line line = vtkLineSource() line.SetPoint1(start) line.SetPoint2(end) # Line Mapper line_mapper = vtkPolyDataMapper() line_mapper.SetInputConnection(line.GetOutputPort()) self.edge_colours.append(colour) self.line_mappers.append(line_mapper) # Bar bar = vtkTubeFilter() bar.SetInputConnection(line.GetOutputPort()) bar.SetRadius(2.5) self.bar_data.append(bar) # Bar Mapper # Tried this, but mapping the ribbon caused beaucoup errors, # debugging would take a week.There must be some kind of way # out of here. # Said the joker to the thief # There's too much confusion # I can't get no relief # No reason to get excited, the thief he kindly spoke # But you and I have been through that # And this is not our fate # So let us not talk falsely now, the hour is getting late. # (2011-08-12) bar_mapper = vtkPolyDataMapper() bar_mapper.SetInputConnection(bar.GetOutputPort()) self.bar_mappers.append(bar_mapper)
def addCube(self,pos,tam,img=False): jpegfile = "struct.jpg" # Read the image data from a file reader = vtk.vtkJPEGReader() reader.SetFileName(jpegfile) (x,y,z) = pos (i,j,k) = tam cubito = vtk.vtkCubeSource() cubito.SetXLength(0.2*i) cubito.SetYLength(0.2*j) cubito.SetZLength(0.2*k) cubito.SetCenter((x,y,z)) if img == True: # Create texture object texture = vtk.vtkTexture() if vtk.VTK_MAJOR_VERSION <= 5: texture.SetInput(reader.GetOutput()) else: texture.SetInputConnection(reader.GetOutputPort()) # Map texture coordinates map_to_sphere = vtk.vtkTextureMapToPlane() if vtk.VTK_MAJOR_VERSION <= 5: map_to_sphere.SetInput(cubito.GetOutput()) else: map_to_sphere.SetInputConnection(cubito.GetOutputPort()) #map_to_sphere.PreventSeamOn() # Create mapper and set the mapped texture as input mapper = vtk.vtkPolyDataMapper() if vtk.VTK_MAJOR_VERSION <= 5: mapper.SetInput(map_to_sphere.GetOutput()) else: mapper.SetInputConnection(map_to_sphere.GetOutputPort()) planeMapper = vtk.vtkPolyDataMapper() planeMapper.SetInputConnection(cubito.GetOutputPort()) planeActor = (vtk.vtkActor()) if (img == True): planeActor.SetMapper(mapper) else: planeActor.SetMapper(planeMapper)# mapper planeMapper planeActor.DragableOn() planeActor.SetDragable(1) if (img== True): planeActor.SetTexture(texture) else: planeActor.GetProperty().SetColor(.0,.3,.6) planeActor.GetProperty().SetOpacity(0.95) #planeActor.GetProperty().SetAmbient(0) #planeActor.GetProperty().SetDiffuse(0.9) #planeActor.GetProperty().SetSpecular(0.1) self.render.AddActor(planeActor) return planeActor
def main(self): print("main builder") window = self.widget.GetRenderWindow() window.AddRenderer(self.rend) self.addGeometry() self.addAltGeometry() self.buildLookupTable() #self.startWireframeLight() self.createTriAxes() textSize = 14 * self.magnify self.createText([5, 50], 'Max ', textSize) # text actor 0 self.createText([5, 35], 'Min ', textSize) # text actor 1 self.createText([5, 20], 'Word1', textSize) # text actor 2 self.createText([5, 5], 'Word2', textSize) # text actor 3 #self.createText([5,35],'Yet Again', textSize) # Create the usual rendering stuff. self.get_edges() if self.is_edges: prop = self.edgeActor.GetProperty() prop.EdgeVisibilityOn() else: prop = self.edgeActor.GetProperty() prop.EdgeVisibilityOff() self.rend.GetActiveCamera().ParallelProjectionOn() self.rend.SetBackground(.1, .2, .4) vtk.vtkPolyDataMapper().SetResolveCoincidentTopologyToPolygonOffset() self.rend.ResetCamera()
def plotvtk(mesh,boundary): meshMapper = vtk.vtkPolyDataMapper() meshMapper.SetInputConnection(mesh.GetOutputPort()) meshActor = vtk.vtkActor() meshActor.SetMapper(meshMapper) meshActor.GetProperty().SetEdgeColor(0, 0, 1) meshActor.GetProperty().SetInterpolationToFlat() meshActor.GetProperty().SetRepresentationToWireframe() boundaryMapper = vtk.vtkPolyDataMapper() if vtk.VTK_MAJOR_VERSION <= 5: boundaryMapper.SetInputConnection(boundary.GetProducerPort()) else: boundaryMapper.SetInputData(boundary) boundaryActor = vtk.vtkActor() boundaryActor.SetMapper(boundaryMapper) boundaryActor.GetProperty().SetColor(1, 0, 0) renderer = vtk.vtkRenderer() renderWindow = vtk.vtkRenderWindow() renderWindow.AddRenderer(renderer) renderWindowInteractor = vtk.vtkRenderWindowInteractor() renderWindowInteractor.SetRenderWindow(renderWindow) renderer.AddActor(meshActor) renderer.AddActor(boundaryActor) renderer.SetBackground(.3, .6, .3) renderWindowInteractor.Initialize() renderWindow.Render() renderWindowInteractor.Start()
def Execute(self): if (self._Surface == None): self.PrintError('vmtkPickPointSeedSelector Error: Surface not set.') return self._SourceSeedIds.Initialize() self._TargetSeedIds.Initialize() if not self.vmtkRenderer: self.vmtkRenderer = vmtkrenderer.vmtkRenderer() self.vmtkRenderer.Initialize() self.OwnRenderer = 1 glyphs = vtk.vtkGlyph3D() glyphSource = vtk.vtkSphereSource() glyphs.SetInput(self.PickedSeeds) glyphs.SetSource(glyphSource.GetOutput()) glyphs.SetScaleModeToDataScalingOff() glyphs.SetScaleFactor(self._Surface.GetLength()*0.01) glyphMapper = vtk.vtkPolyDataMapper() glyphMapper.SetInput(glyphs.GetOutput()) self.SeedActor = vtk.vtkActor() self.SeedActor.SetMapper(glyphMapper) self.SeedActor.GetProperty().SetColor(1.0,0.0,0.0) self.SeedActor.PickableOff() self.vmtkRenderer.Renderer.AddActor(self.SeedActor) self.vmtkRenderer.RenderWindowInteractor.AddObserver("KeyPressEvent", self.KeyPressed) surfaceMapper = vtk.vtkPolyDataMapper() surfaceMapper.SetInput(self._Surface) surfaceMapper.ScalarVisibilityOff() surfaceActor = vtk.vtkActor() surfaceActor.SetMapper(surfaceMapper) surfaceActor.GetProperty().SetOpacity(1.0) self.vmtkRenderer.Renderer.AddActor(surfaceActor) self.OutputText('Please position the mouse and press space to add source points, \'u\' to undo\n') any = 0 while any == 0: self.InitializeSeeds() self.vmtkRenderer.Render() any = self.PickedSeedIds.GetNumberOfIds() self._SourceSeedIds.DeepCopy(self.PickedSeedIds) self.OutputText('Please position the mouse and press space to add target points, \'u\' to undo\n') any = 0 while any == 0: self.InitializeSeeds() self.vmtkRenderer.Render() any = self.PickedSeedIds.GetNumberOfIds() self._TargetSeedIds.DeepCopy(self.PickedSeedIds) if self.OwnRenderer: self.vmtkRenderer.Deallocate()
def __init__(self, parent, visualizer, **kws): """ Initialization """ self.x, self.y, self.z = -1, -1, -1 VisualizationModule.__init__(self, parent, visualizer, **kws) self.on = 0 self.renew = 1 self.mapper = vtk.vtkPolyDataMapper() self.eventDesc = "Rendering orthogonal slices" self.outline = vtk.vtkOutlineFilter() self.outlineMapper = vtk.vtkPolyDataMapper() self.outlineActor = vtk.vtkActor() self.outlineActor.SetMapper(self.outlineMapper) self.picker = vtk.vtkCellPicker() self.picker.SetTolerance(0.005) self.planeWidgetX = vtk.vtkImagePlaneWidget() self.planeWidgetX.DisplayTextOn() self.planeWidgetX.SetPicker(self.picker) self.planeWidgetX.SetKeyPressActivationValue("x") #self.planeWidgetX.UserControlledLookupTableOn() self.prop1 = self.planeWidgetX.GetPlaneProperty() #self.prop1.SetColor(1, 0, 0) self.planeWidgetX.SetResliceInterpolateToCubic() self.planeWidgetY = vtk.vtkImagePlaneWidget() self.planeWidgetY.DisplayTextOn() self.planeWidgetY.SetPicker(self.picker) self.planeWidgetY.SetKeyPressActivationValue("y") self.prop2 = self.planeWidgetY.GetPlaneProperty() self.planeWidgetY.SetResliceInterpolateToCubic() #self.planeWidgetY.UserControlledLookupTableOn() #self.prop2.SetColor(1, 1, 0) # for the z-slice, turn off texture interpolation: # interpolation is now nearest neighbour, to demonstrate # cross-hair cursor snapping to pixel centers self.planeWidgetZ = vtk.vtkImagePlaneWidget() self.planeWidgetZ.DisplayTextOn() self.planeWidgetZ.SetPicker(self.picker) self.planeWidgetZ.SetKeyPressActivationValue("z") self.prop3 = self.planeWidgetZ.GetPlaneProperty() #self.prop3.SetColor(1, 0, 1) #self.planeWidgetZ.UserControlledLookupTableOn() self.planeWidgetZ.SetResliceInterpolateToCubic() self.renderer = self.parent.getRenderer() self.renderer.AddActor(self.outlineActor) self.useOutline = 1 iactor = self.wxrenwin.GetRenderWindow().GetInteractor() self.planeWidgetX.SetInteractor(iactor) self.planeWidgetY.SetInteractor(iactor) self.planeWidgetZ.SetInteractor(iactor) lib.messenger.connect(None, "zslice_changed", self.setZ) self.filterDesc = "View orthogonal slices"
def visQuadFunc(): """ vtk sample scene with iso contours """ # VTK supports implicit functions of the form f(x,y,z)=constant. These # functions can represent things spheres, cones, etc. Here we use a # general form for a quadric to create an elliptical data field. quadric = vtk.vtkQuadric() quadric.SetCoefficients(.5, 1, .2, 0, .1, 0, 0, .2, 0, 0) # vtkSampleFunction samples an implicit function over the x-y-z range # specified (here it defaults to -1,1 in the x,y,z directions). sample = vtk.vtkSampleFunction() sample.SetSampleDimensions(30, 30, 30) sample.SetImplicitFunction(quadric) # Create five surfaces F(x,y,z) = constant between range specified. The # GenerateValues() method creates n isocontour values between the range # specified. contours = vtk.vtkContourFilter() contours.SetInputConnection(sample.GetOutputPort()) contours.GenerateValues(8, 0.0, 1.2) contMapper = vtk.vtkPolyDataMapper() contMapper.SetInputConnection(contours.GetOutputPort()) contMapper.SetScalarRange(0.0, 1.2) contActor = vtk.vtkActor() contActor.SetMapper(contMapper) # We'll put a simple outline around the data. outline = vtk.vtkOutlineFilter() outline.SetInputConnection(sample.GetOutputPort()) outlineMapper = vtk.vtkPolyDataMapper() outlineMapper.SetInputConnection(outline.GetOutputPort()) outlineActor = vtk.vtkActor() outlineActor.SetMapper(outlineMapper) outlineActor.GetProperty().SetColor(1, 0.5, 0) # extract data from the volume extract = vtk.vtkExtractVOI() extract.SetInputConnection(sample.GetOutputPort()) extract.SetVOI(0, 29, 0, 29, 15, 15) extract.SetSampleRate(1, 2, 3) contours2 = vtk.vtkContourFilter() contours2.SetInputConnection(extract.GetOutputPort()) contours2.GenerateValues(8, 0.0, 1.2) contMapper2 = vtk.vtkPolyDataMapper() contMapper2.SetInputConnection(contours2.GetOutputPort()) contMapper2.SetScalarRange(0.0, 1.2) contActor2 = vtk.vtkActor() contActor2.SetMapper(contMapper2) return contActor, contActor2, outlineActor, contours, contours2
def CreateAxes(): global xAxis, yAxis, zAxis, popSplatter # Create axes. popSplatter.Update() bounds = popSplatter.GetOutput().GetBounds() axes = vtk.vtkAxes() axes.SetOrigin(bounds[0], bounds[2], bounds[4]) axes.SetScaleFactor(popSplatter.GetOutput().GetLength()/5.0) axesTubes = vtk.vtkTubeFilter() axesTubes.SetInputConnection(axes.GetOutputPort()) axesTubes.SetRadius(axes.GetScaleFactor()/25.0) axesTubes.SetNumberOfSides(6) axesMapper = vtk.vtkPolyDataMapper() axesMapper.SetInputConnection(axesTubes.GetOutputPort()) axesActor = vtk.vtkActor() axesActor.SetMapper(axesMapper) # Label the axes. XText = vtk.vtkVectorText() XText.SetText(xAxis) XTextMapper = vtk.vtkPolyDataMapper() XTextMapper.SetInputConnection(XText.GetOutputPort()) XActor = vtk.vtkFollower() XActor.SetMapper(XTextMapper) XActor.SetScale(0.02, .02, .02) XActor.SetPosition(0.35, -0.05, -0.05) XActor.GetProperty().SetColor(0, 0, 0) YText = vtk.vtkVectorText() YText.SetText(yAxis) YTextMapper = vtk.vtkPolyDataMapper() YTextMapper.SetInputConnection(YText.GetOutputPort()) YActor = vtk.vtkFollower() YActor.SetMapper(YTextMapper) YActor.SetScale(0.02, .02, .02) YActor.SetPosition(-0.05, 0.35, -0.05) YActor.GetProperty().SetColor(0, 0, 0) ZText = vtk.vtkVectorText() ZText.SetText(zAxis) ZTextMapper = vtk.vtkPolyDataMapper() ZTextMapper.SetInputConnection(ZText.GetOutputPort()) ZActor = vtk.vtkFollower() ZActor.SetMapper(ZTextMapper) ZActor.SetScale(0.02, .02, .02) ZActor.SetPosition(-0.05, -0.05, 0.35) ZActor.GetProperty().SetColor(0, 0, 0) return axesActor, XActor, YActor, ZActor
def BuildBackdrop (minX, maxX, minY, maxY, minZ, maxZ, thickness): global basePlane global baseMapper global base global backPlane global backMapper global back global left global leftPlane global leftMapper if not basePlane: basePlane = vtk.vtkCubeSource() basePlane.SetCenter( (maxX + minX)/2.0, minY, (maxZ + minZ)/2.0) basePlane.SetXLength(maxX-minX) basePlane.SetYLength(thickness) basePlane.SetZLength(maxZ - minZ) if not baseMapper: baseMapper = vtk.vtkPolyDataMapper() baseMapper.SetInput(basePlane.GetOutput()) if not base: base = vtk.vtkActor() base.SetMapper(baseMapper) if not backPlane: backPlane = vtk.vtkCubeSource() backPlane.SetCenter( (maxX + minX)/2.0, (maxY + minY)/2.0, minZ) backPlane.SetXLength(maxX-minX) backPlane.SetYLength(maxY - minY) backPlane.SetZLength(thickness) if not backMapper: backMapper = vtk.vtkPolyDataMapper() backMapper.SetInput(backPlane.GetOutput()) if not back: back = vtk.vtkActor() back.SetMapper(backMapper) if not leftPlane: leftPlane = vtk.vtkCubeSource() leftPlane.SetCenter( minX, (maxY+minY)/2.0, (maxZ+minZ)/2.0) leftPlane.SetXLength(thickness) leftPlane.SetYLength(maxY-minY) leftPlane.SetZLength(maxZ-minZ) if not leftMapper: leftMapper = vtk.vtkPolyDataMapper() leftMapper.SetInput(leftPlane.GetOutput()) if not left: left = vtk.vtkActor() left.SetMapper(leftMapper) return [base, back, left]
def SetInputMapper(self): self.inputMapper1 = vtk.vtkPolyDataMapper() self.inputMapper1.SetInputData(self.inputPolyData1) self.inputMapper2 = vtk.vtkPolyDataMapper() self.inputMapper2.SetInputData(self.inputPolyData2) self.inputMapper3 = vtk.vtkPolyDataMapper() self.inputMapper3.SetInputData(self.inputPolyData3) self.inputMapper4 = vtk.vtkPolyDataMapper() self.inputMapper4.SetInputData(self.inputPolyData4)
def Execute(self): self._SourceSeedIds.Initialize() if not self.vmtkRenderer: self.vmtkRenderer = vmtkrenderer.vmtkRenderer() self.vmtkRenderer.Initialize() self.OwnRenderer = 1 glyphs = vtk.vtkGlyph3D() glyphSource = vtk.vtkSphereSource() glyphs.SetInputData(self.PickedSeeds) glyphs.SetSourceConnection(glyphSource.GetOutputPort()) glyphs.SetScaleModeToDataScalingOff() glyphs.SetScaleFactor(self._Surface.GetLength()*0.01) glyphMapper = vtk.vtkPolyDataMapper() glyphMapper.SetInputConnection(glyphs.GetOutputPort()) self.SeedActor = vtk.vtkActor() self.SeedActor.SetMapper(glyphMapper) self.SeedActor.GetProperty().SetColor(1.0,0.0,0.0) self.SeedActor.PickableOff() self.vmtkRenderer.Renderer.AddActor(self.SeedActor) self.vmtkRenderer.AddKeyBinding('u','Undo.',self.UndoCallback) self.vmtkRenderer.AddKeyBinding('space','Add points.',self.PickCallback) surfaceMapper = vtk.vtkPolyDataMapper() surfaceMapper.SetInputData(self._Surface) surfaceMapper.ScalarVisibilityOff() surfaceActor = vtk.vtkActor() surfaceActor.SetMapper(surfaceMapper) surfaceActor.GetProperty().SetOpacity(1) self.vmtkRenderer.Renderer.AddActor(surfaceActor) # create a text actor txt = vtk.vtkTextActor() info = "Position mouse and press space. " info += "Select seeds in this order: RSpv, RIpv, LIpv, LSpv. " info += "Fifth seed requires --use_laa_seed command." txt.SetInput(info) txtprop=txt.GetTextProperty() txtprop.SetFontFamilyToArial() txtprop.SetFontSize(13) txtprop.SetColor(1, 1, 1) txt.SetDisplayPosition(0, 10) self.vmtkRenderer.Renderer.AddActor(txt) any = 0 while any == 0: self.InitializeSeeds() self.vmtkRenderer.Render() any = self.PickedSeedIds.GetNumberOfIds() self._SourceSeedIds.DeepCopy(self.PickedSeedIds) if self.OwnRenderer: self.vmtkRenderer.Deallocate()
def visualise_color(surface,ref,case): """Visualise surface in solid color and 'ref' in trasparent.""" # create a text actor txt = vtk.vtkTextActor() txt.SetInput(case) txtprop=txt.GetTextProperty() txtprop.SetFontFamilyToArial() txtprop.SetFontSize(18) txtprop.SetColor(0, 0, 0) txt.SetDisplayPosition(20, 30) # create a rendering window, renderer, and renderwindowinteractor ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) iren = vtk.vtkRenderWindowInteractor() style = vtk.vtkInteractorStyleTrackballCamera() iren.SetInteractorStyle(style) iren.SetRenderWindow(renWin) # surface mapper and actor surfacemapper = vtk.vtkPolyDataMapper() surfacemapper.SetInputData(surface) surfacemapper.SetScalarModeToUsePointFieldData() surfaceactor = vtk.vtkActor() surfaceactor.GetProperty().SetColor(288/255, 26/255, 28/255) surfaceactor.SetMapper(surfacemapper) # refsurface mapper and actor refmapper = vtk.vtkPolyDataMapper() refmapper.SetInputData(ref) refmapper.SetScalarModeToUsePointFieldData() refactor = vtk.vtkActor() refactor.GetProperty().SetOpacity(0.5) refactor.GetProperty().SetColor(1, 1, 1) refactor.SetMapper(refmapper) # assign actors to the renderer ren.AddActor(surfaceactor) ren.AddActor(refactor) ren.AddActor(txt) # set the background and size; zoom in; and render ren.SetBackground(1, 1, 1) renWin.SetSize(800 , 800) ren.ResetCamera() ren.GetActiveCamera().Zoom(1) # enable user interface interactor iren.Initialize() renWin.Render() iren.Start()
def addAltGeometry(self): aQuadMapper = vtk.vtkDataSetMapper() aQuadMapper.SetInput(self.grid2) #aQuadMapper.SetInput(Filter.GetOutput()) geometryActor = vtk.vtkActor() geometryActor.SetMapper(aQuadMapper) #geometryActor.AddPosition(2, 0, 2) #geometryActor.GetProperty().SetDiffuseColor(0, 0, 1) # blue geometryActor.GetProperty().SetDiffuseColor(1, 1, 0) # green self.rend.AddActor(geometryActor) vtk.vtkPolyDataMapper().SetResolveCoincidentTopologyToPolygonOffset()
def __init__(self, parent = None): super(VTKFrame, self).__init__(parent) self.vtkWidget = QVTKRenderWindowInteractor(self) vl = QtGui.QVBoxLayout(self) vl.addWidget(self.vtkWidget) vl.setContentsMargins(0, 0, 0, 0) self.ren = vtk.vtkRenderer() self.vtkWidget.GetRenderWindow().AddRenderer(self.ren) self.iren = self.vtkWidget.GetRenderWindow().GetInteractor() #Create a cube cube=vtk.vtkCubeSource() cube.SetXLength(40) cube.SetYLength(30) cube.SetZLength(20) cubeMapper=vtk.vtkPolyDataMapper() cubeMapper.SetInputConnection(cube.GetOutputPort()) #create a plane to cut,here it cuts in the XZ direction (xz normal=(1,0,0);XY =(0,0,1),YZ =(0,1,0) plane=vtk.vtkPlane() plane.SetOrigin(10,0,0) plane.SetNormal(1,0,0) #create cutter cutter=vtk.vtkCutter() cutter.SetCutFunction(plane) cutter.SetInputConnection(cube.GetOutputPort()) cutter.Update() cutterMapper=vtk.vtkPolyDataMapper() cutterMapper.SetInputConnection( cutter.GetOutputPort()) #create plane actor planeActor=vtk.vtkActor() planeActor.GetProperty().SetColor(1.0,1,0) planeActor.GetProperty().SetLineWidth(2) planeActor.SetMapper(cutterMapper) #create cube actor cubeActor=vtk.vtkActor() cubeActor.GetProperty().SetColor(0.5,1,0.5) cubeActor.GetProperty().SetOpacity(0.5) cubeActor.SetMapper(cubeMapper) #create renderers and add actors of plane and cube self.ren.AddActor(planeActor) self.ren.AddActor(cubeActor) self.ren.ResetCamera() self._initialized = False
def __init__(self): self.source = None self.target = None self.transformed = None self.iteration =200 self.icp= vtk.vtkIterativeClosestPointTransform() self.icptf = vtk.vtkTransformPolyDataFilter() self.mappers =vtk.vtkPolyDataMapper() self.mappert =vtk.vtkPolyDataMapper() self.mappertf =vtk.vtkPolyDataMapper() self.actors = vtk.vtkActor() self.actort = vtk.vtkActor() self.actortf = vtk.vtkActor() self.centroidon= False
def initializeView(): mapOutline = vtk.vtkPolyDataMapper() mapOutline.SetInputConnection(outlineData.GetOutputPort()) outline = vtk.vtkActor() outline.SetMapper(mapOutline) outline.GetProperty().SetColor(0, 0, 0) skinMapper = vtk.vtkPolyDataMapper() skinMapper.SetInputConnection(skinNormals.GetOutputPort()) skinMapper.ScalarVisibilityOff() skin = vtk.vtkActor() skin.SetMapper(skinMapper) attachProp(outline, vtkNode) attachProp(skin, vtkNode)
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 showAxis(self): if self.axis: xmin, xmax, ymin, ymax, zmin, zmax = self.bounds[:] axes=vtk.vtkAxes() axes.SetOrigin(0.0,0.0,0.0) axes.SetScaleFactor(0.1*max([xmax-xmin,ymax-ymin,zmax-zmin])) axesTubes=vtk.vtkTubeFilter() axesTubes.SetInputConnection(axes.GetOutputPort()) axesTubes.SetRadius(0.2) axesTubes.SetNumberOfSides(6) axesMapper=vtk.vtkPolyDataMapper() axesMapper.SetInputConnection(axesTubes.GetOutputPort()) axesActor=vtk.vtkActor() axesActor.SetMapper(axesMapper) XText=vtk.vtkVectorText() XText.SetText("X") XTextMapper=vtk.vtkPolyDataMapper() XTextMapper.SetInputConnection(XText.GetOutputPort()) XActor=vtk.vtkFollower() XActor.SetMapper(XTextMapper) XActor.SetScale(2.0, 2.0, 2.0) XActor.SetPosition(1.11*xmax, ymin, zmin) XActor.GetProperty().SetColor(0,0,0) XActor.SetCamera(self.cam) YText=vtk.vtkVectorText() YText.SetText("Y") YTextMapper=vtk.vtkPolyDataMapper() YTextMapper.SetInputConnection(YText.GetOutputPort()) YActor=vtk.vtkFollower() YActor.SetMapper(YTextMapper) YActor.SetScale(2.0, 2.0, 2.0) YActor.SetPosition(xmin, 1.11*ymax, zmin) YActor.GetProperty().SetColor(0,0,0) YActor.SetCamera(self.cam) ZText=vtk.vtkVectorText() ZText.SetText("Z") ZTextMapper=vtk.vtkPolyDataMapper() ZTextMapper.SetInputConnection(ZText.GetOutputPort()) ZActor=vtk.vtkFollower() ZActor.SetMapper(ZTextMapper) ZActor.SetScale(2.0, 2.0, 2.0) ZActor.SetPosition(xmin, ymin, 1.11*zmax) ZActor.GetProperty().SetColor(0,0,0) ZActor.SetCamera(self.cam) self.ren.AddActor(axesActor) self.ren.AddActor(XActor) self.ren.AddActor(YActor) self.ren.AddActor(ZActor)
def Execute(self): if self.Surface == None: self.PrintError('Error: No input surface.') # cleaner = vtk.vtkCleanPolyData() # cleaner.SetInput(self.Surface) # cleaner.Update() # # triangleFilter = vtk.vtkTriangleFilter() # triangleFilter.SetInput(cleaner.GetOutput()) # triangleFilter.Update() # # self.Surface = triangleFilter.GetOutput() boundaryIds = vtk.vtkIdList() if self.Interactive: if not self.vmtkRenderer: import vmtkrenderer self.vmtkRenderer = vmtkrenderer.vmtkRenderer() self.vmtkRenderer.Initialize() self.OwnRenderer = 1 self.vmtkRenderer.RegisterScript(self) boundaryExtractor = vtkvmtk.vtkvmtkPolyDataBoundaryExtractor() boundaryExtractor.SetInput(self.Surface) boundaryExtractor.Update() boundaries = boundaryExtractor.GetOutput() numberOfBoundaries = boundaries.GetNumberOfCells() seedPoints = vtk.vtkPoints() for i in range(numberOfBoundaries): barycenter = [0.0, 0.0, 0.0] vtkvmtk.vtkvmtkBoundaryReferenceSystems.ComputeBoundaryBarycenter( boundaries.GetCell(i).GetPoints(), barycenter) seedPoints.InsertNextPoint(barycenter) seedPolyData = vtk.vtkPolyData() seedPolyData.SetPoints(seedPoints) seedPolyData.Update() labelsMapper = vtk.vtkLabeledDataMapper() labelsMapper.SetInput(seedPolyData) labelsMapper.SetLabelModeToLabelIds() labelsActor = vtk.vtkActor2D() labelsActor.SetMapper(labelsMapper) self.vmtkRenderer.Renderer.AddActor(labelsActor) surfaceMapper = vtk.vtkPolyDataMapper() surfaceMapper.SetInput(self.Surface) surfaceMapper.ScalarVisibilityOff() surfaceActor = vtk.vtkActor() surfaceActor.SetMapper(surfaceMapper) surfaceActor.GetProperty().SetOpacity(0.25) self.vmtkRenderer.Renderer.AddActor(surfaceActor) #self.vmtkRenderer.Render() #self.vmtkRenderer.Renderer.RemoveActor(labelsActor) #self.vmtkRenderer.Renderer.RemoveActor(surfaceActor) ok = False while not ok: labelString = self.InputText("Please input boundary ids: ", self.LabelValidator) labels = [int(label) for label in labelString.split()] ok = True for label in labels: if label not in range(numberOfBoundaries): ok = False for label in labels: boundaryIds.InsertNextId(label) if self.Method == 'simple': capper = vtkvmtk.vtkvmtkSimpleCapPolyData() capper.SetInput(self.Surface) if self.Interactive: capper.SetBoundaryIds(boundaryIds) capper.SetCellEntityIdsArrayName(self.CellEntityIdsArrayName) capper.SetCellEntityIdOffset(self.CellEntityIdOffset) capper.Update() self.Surface = capper.GetOutput() elif self.Method == 'centerpoint': capper = vtkvmtk.vtkvmtkCapPolyData() capper.SetInput(self.Surface) if self.Interactive: capper.SetBoundaryIds(boundaryIds) capper.SetDisplacement(0.0) capper.SetInPlaneDisplacement(0.0) capper.Update() self.Surface = capper.GetOutput() elif self.Method == 'smooth': triangle = vtk.vtkTriangleFilter() triangle.SetInput(self.Surface) triangle.PassLinesOff() triangle.PassVertsOff() triangle.Update() capper = vtkvmtk.vtkvmtkSmoothCapPolyData() capper.SetInput(triangle.GetOutput()) capper.SetConstraintFactor(self.ConstraintFactor) capper.SetNumberOfRings(self.NumberOfRings) if self.Interactive: capper.SetBoundaryIds(boundaryIds) capper.Update() self.Surface = capper.GetOutput() elif self.Method == 'annular': capper = vtkvmtk.vtkvmtkAnnularCapPolyData() capper.SetInput(self.Surface) capper.SetCellEntityIdsArrayName(self.CellEntityIdsArrayName) capper.SetCellEntityIdOffset(self.CellEntityIdOffset) capper.Update() self.Surface = capper.GetOutput() if self.TriangleOutput == 1: triangle = vtk.vtkTriangleFilter() triangle.SetInput(self.Surface) triangle.PassLinesOff() triangle.PassVertsOff() triangle.Update() self.Surface = triangle.GetOutput() normals = vtk.vtkPolyDataNormals() normals.SetInput(self.Surface) normals.AutoOrientNormalsOn() normals.SplittingOff() normals.ConsistencyOn() normals.Update() self.Surface = normals.GetOutput() if self.Surface.GetSource(): self.Surface.GetSource().UnRegisterAllOutputs()
pl3d.SetXYZFileName(VTK_DATA_ROOT + "/Data/combxyz.bin") pl3d.SetQFileName(VTK_DATA_ROOT + "/Data/combq.bin") pl3d.SetScalarFunctionNumber(100) pl3d.SetVectorFunctionNumber(202) pl3d.Update() pl3d_output = pl3d.GetOutput().GetBlock(0) # We use a rake to generate a series of streamline starting points # scattered along a line. Each point will generate a streamline. These # streamlines are then fed to the vtkRuledSurfaceFilter which stitches # the lines together to form a surface. rake = vtk.vtkLineSource() rake.SetPoint1(15, -5, 32) rake.SetPoint2(15, 5, 32) rake.SetResolution(21) rakeMapper = vtk.vtkPolyDataMapper() rakeMapper.SetInputConnection(rake.GetOutputPort()) rakeActor = vtk.vtkActor() rakeActor.SetMapper(rakeMapper) integ = vtk.vtkRungeKutta4() sl = vtk.vtkStreamLine() sl.SetInputData(pl3d_output) sl.SetSourceConnection(rake.GetOutputPort()) sl.SetIntegrator(integ) sl.SetMaximumPropagationTime(0.1) sl.SetIntegrationStepLength(0.1) sl.SetIntegrationDirectionToBackward() sl.SetStepLength(0.001) # The ruled surface stiches together lines with triangle strips.
def get_screenshot(path, view, center=False): reader = vtk.vtkPolyDataReader() reader.SetFileName(path) reader.Update() fow = vtk.vtkFileOutputWindow() fow.SetFileName('ow.txt') ow = vtk.vtkOutputWindow() ow.SetInstance(fow) surf = reader.GetOutput() # surf.ColorCells(1, 0, 0) # create a rendering window and renderer ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) WIDTH = 640 HEIGHT = 500 renWin.SetSize(WIDTH, HEIGHT) # create a renderwindowinteractor iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # mapper surfMapper = vtk.vtkPolyDataMapper() surfMapper.SetInputData(surf) # actor surfActor = vtk.vtkActor() surfActor.SetMapper(surfMapper) # surfActor.GetProperty().SetColor(1, 0, 0) if not center: centerOfMassFilter = vtk.vtkCenterOfMass() centerOfMassFilter.SetInputData(surf) centerOfMassFilter.SetUseScalarsAsWeights(False) centerOfMassFilter.Update() center = centerOfMassFilter.GetCenter() print(center) camera = vtk.vtkCamera() dist_x = 0 dist_z = 300 if view == 'posterior': pos = (center[0] - dist_x, center[1] + 400, center[2] - dist_z) elif view == 'anterior': pos = (center[0] + dist_x, center[1] + 0, center[2] + dist_z) else: raise ValueError('view is not supported: {}'.format(view)) camera.SetPosition(pos) camera.SetFocalPoint(center[0], center[1], center[2]) # assign actor to the renderer ren.AddActor(surfActor) ren.SetActiveCamera(camera) ren.SetBackground(1, 1, 1) renWin.Render() # screenshot code: w2if = vtk.vtkWindowToImageFilter() w2if.SetInput(renWin) w2if.Update() writer = vtk.vtkPNGWriter() writer.SetFileName("screenshots/screenshot.png") writer.SetInputData(w2if.GetOutput()) writer.Write() # iren.Initialize() # renWin.Render() # iren.Start() im = sitk.GetArrayFromImage(sitk.ReadImage('screenshots/screenshot.png')) return im[100:400, 25:605], center
def main(argv): colors = vtk.vtkNamedColors() # # Next we create an instance of vtkConeSource and set some of its # properties. The instance of vtkConeSource 'cone' is part of a # visualization pipeline (it is a source process object) it produces data # (output type is vtkPolyData) which other filters may process. # cone = vtk.vtkConeSource() cone.SetHeight(3.0) cone.SetRadius(1.0) cone.SetResolution(10) # # In this example we terminate the pipeline with a mapper process object. # (Intermediate filters such as vtkShrinkPolyData could be inserted in # between the source and the mapper.) We create an instance of # vtkPolyDataMapper to map the polygonal data into graphics primitives. We # connect the output of the cone source to the input of this mapper. # coneMapper = vtk.vtkPolyDataMapper() coneMapper.SetInputConnection(cone.GetOutputPort()) # # Create an actor to represent the cone. The actor orchestrates rendering # of the mapper's graphics primitives. An actor also refers to properties # via a vtkProperty instance, and includes an internal transformation # matrix. We set this actor's mapper to be coneMapper which we created # above. # coneActor = vtk.vtkActor() coneActor.SetMapper(coneMapper) coneActor.GetProperty().SetColor(colors.GetColor3d('MistyRose')) # # Create two renderers and assign actors to them. A renderer renders into # a viewport within the vtkRenderWindow. It is part or all of a window on # the screen and it is responsible for drawing the actors it has. We also # set the background color here. In this example we are adding the same # actor to two different renderers it is okay to add different actors to # different renderers as well. # ren1 = vtk.vtkRenderer() ren1.AddActor(coneActor) ren1.SetBackground(colors.GetColor3d('RoyalBlue')) ren1.SetViewport(0.0, 0.0, 0.5, 1.0) ren2 = vtk.vtkRenderer() ren2.AddActor(coneActor) ren2.SetBackground(colors.GetColor3d('DodgerBlue')) ren2.SetViewport(0.5, 0.0, 1.0, 1.0) # # Finally we create the render window which will show up on the screen. # We put our renderer into the render window using AddRenderer. We also # set the size to be 300 pixels by 300. # renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren1) renWin.AddRenderer(ren2) renWin.SetSize(600, 300) renWin.SetWindowName('Tutorial_Step3') # # Make one view 90 degrees from other. # ren1.ResetCamera() ren1.GetActiveCamera().Azimuth(90) # # Now we loop over 360 degrees and render the cones each time. # for i in range(0, 360): # render the image renWin.Render() # rotate the active camera by one degree ren1.GetActiveCamera().Azimuth(1) ren2.GetActiveCamera().Azimuth(1)
# print( "P-Value" ) # print( P_val ) ######################################## ##### Visualization ###### ######################################## # Visualize a sphere coordinate sphere = vtk.vtkSphereSource() sphere.SetThetaResolution(30) sphere.SetPhiResolution(30) sphere.SetRadius(1.0) sphere.SetCenter(0.0, 0.0, 0.0) sphere.SetLatLongTessellation(True) sphere.Update() conMapper = vtk.vtkPolyDataMapper() conMapper.SetInputData(sphere.GetOutput()) conMapper.ScalarVisibilityOff() conMapper.Update() conActor = vtk.vtkActor() conActor.SetMapper(conMapper) conActor.GetProperty().SetOpacity(1) conActor.GetProperty().SetColor(0.9, 0.9, 0.9) conActor.GetProperty().SetEdgeColor(0.4, 0.4, 0.7) conActor.GetProperty().EdgeVisibilityOn() conActor.GetProperty().SetAmbient(0.3) conActor.GetProperty().SetDiffuse(0.375) conActor.GetProperty().SetSpecular(0.0) # Visualize spherical points - Red
def __init__(self, *args, **kwargs): super(WorldPlotWindow, self).__init__(*args, **kwargs) self.keyframe = 0 self.numKeyframes = 1 self.dataSets = [] self.projCenterLongitude = 0.0 self.projCenterLatitude = 0.0 self.colorBarHeight = 60 self.dataSetForColorBar = -1 self.renderer2D = vtk.vtkRenderer() self.renderer2D.SetBackground(1, 1, 1) self.renderer3D = vtk.vtkRenderer() self.renderer3D.SetBackground(0, 0, 0) self.style2D = vtkInteractorStyleWorldPlot2D() self.style3D = vtkInteractorStyleWorldPlot3D() # Globe (only applicable for 3D) sphere = vtk.vtkSphereSource() sphere.SetRadius(1) sphere.SetPhiResolution(30) sphere.SetThetaResolution(60) mapper3D = vtk.vtkPolyDataMapper() actor3D = vtk.vtkActor() mapper3D.SetInputConnection(sphere.GetOutputPort()) actor3D.SetMapper(mapper3D) self.renderer3D.AddActor(actor3D) def onWorldViewChanged(caller, event, calldata=None): wx.PostEvent(self, WorldViewChangedEvent()) self.style2D.AddObserver("WorldViewChanged", onWorldViewChanged) self.style3D.AddObserver("WorldViewChanged", onWorldViewChanged) # Grid lines self.geoGridData = vtkGeoGridData() self.renderer2D.AddActor2D(self.geoGridData.GetActor2D()) self.renderer3D.AddActor(self.geoGridData.GetActor3D()) self.style2D.GetTransformCollection().AddItem( self.geoGridData.GetTransform()) # Coastlines self.coastLineData = vtkGeographyLineData() self.coastLineData.SetMaxLevel(2) self.renderer2D.AddActor2D(self.coastLineData.GetActor2D()) self.renderer3D.AddActor(self.coastLineData.GetActor3D()) self.style2D.GetTransformCollection().AddItem( self.coastLineData.GetTransform()) # Political Borders self.politicalBorderData = vtkGeographyLineData() self.politicalBorderData.SetMaxLevel(1) self.renderer2D.AddActor2D(self.politicalBorderData.GetActor2D()) self.renderer3D.AddActor(self.politicalBorderData.GetActor3D()) self.style2D.GetTransformCollection().AddItem( self.politicalBorderData.GetTransform()) # Plot Title self.titleMapper2D = vtk.vtkTextMapper() self.titleMapper2D.GetTextProperty().SetFontFamilyToArial() self.titleMapper2D.GetTextProperty().SetFontSize(14) self.titleMapper2D.GetTextProperty().SetColor(0, 0, 0) self.titleMapper2D.GetTextProperty().SetShadow(1) self.titleMapper2D.GetTextProperty().SetBold(1) self.titleMapper2D.GetTextProperty().SetItalic(1) self.titleMapper2D.GetTextProperty().SetJustificationToCentered() self.titleActor2D = vtk.vtkActor2D() self.titleActor2D.SetMapper(self.titleMapper2D) self.titleActor2D.GetPositionCoordinate( ).SetCoordinateSystemToNormalizedViewport() self.titleActor2D.SetPosition(0.5, 0.95) self.renderer2D.AddActor2D(self.titleActor2D) self.titleMapper3D = vtk.vtkTextMapper() self.titleMapper3D.GetTextProperty().SetFontFamilyToArial() self.titleMapper3D.GetTextProperty().SetFontSize(14) self.titleMapper3D.GetTextProperty().SetColor(1, 1, 1) self.titleMapper3D.GetTextProperty().SetShadow(1) self.titleMapper3D.GetTextProperty().SetBold(1) self.titleMapper3D.GetTextProperty().SetItalic(1) self.titleMapper3D.GetTextProperty().SetJustificationToCentered() titleActor = vtk.vtkActor2D() titleActor.SetMapper(self.titleMapper3D) titleActor.GetPositionCoordinate( ).SetCoordinateSystemToNormalizedViewport() titleActor.SetPosition(0.5, 0.95) self.renderer3D.AddActor2D(titleActor) # Color Bar self.colorBarRenderer = vtk.vtkRenderer() self.colorBarActor = vtk.vtkScalarBarActor() defaultLut = vtk.vtkLookupTable() defaultLut.SetNumberOfTableValues(1) defaultLut.SetTableValue(0, 0, 0, 0, 0) self.colorBarActor.SetLookupTable(defaultLut) self.colorBarActor.SetOrientationToHorizontal() self.colorBarActor.SetPosition(0.1, 0.1) self.colorBarActor.SetPosition2(0.8, 0.9) self.colorBarActor.SetNumberOfLabels(5) self.colorBarActor.GetLabelTextProperty().SetColor(1, 1, 1) self.colorBarActor.GetLabelTextProperty().ShadowOff() self.colorBarActor.GetLabelTextProperty().SetFontFamilyToArial() self.colorBarActor.GetLabelTextProperty().ItalicOff() self.colorBarActor.GetLabelTextProperty().BoldOff() self.colorBarActor.GetLabelTextProperty().SetJustificationToCentered() self.colorBarActor.GetTitleTextProperty().SetColor(1, 1, 1) self.colorBarActor.GetTitleTextProperty().ShadowOff() self.colorBarActor.GetTitleTextProperty().SetFontFamilyToArial() self.colorBarActor.GetTitleTextProperty().ItalicOff() self.colorBarActor.GetTitleTextProperty().BoldOff() self.colorBarActor.SetLabelFormat("%g") self.colorBarRenderer.AddActor2D(self.colorBarActor) self.colorBarRenderer.InteractiveOff() # Make sure the renderer starts with the default zoom/pan position from style3D. # We need to do this step before the renderer is attached to the renderwindow otherwise the # renderwindow will start to draw itself which breaks the wxVTK binding. self.style3D.SetCurrentRenderer(self.renderer3D) self.style3D.SetDefaultZoom(2.5) self.style3D.SetDefaultView() # start with 3D projection self.projection = PROJECTION_3D self.GetRenderWindow().AddRenderer(self.colorBarRenderer) self.GetRenderWindow().AddRenderer(self.renderer2D) self.GetRenderWindow().AddRenderer(self.renderer3D) self.renderer2D.DrawOff() self.SetInteractorStyle(self.style3D) # By default the colorbar is hidden self.showColorBar = False self.UpdateColorBarSize()
print("Reading volume dataset from " + filename + " ...") reader.Update() # executes the reader print("Done!") # Just for illustration, extract and print the dimensions of the # volume. The string formatting used here is similar to the sprintf # style in C. width, height, depth = reader.GetOutput().GetDimensions() print("Dimensions: %i %i %i" % (width, height, depth)) # Create an outline of the volume # create an outline of the dataset outline = vtk.vtkOutlineFilter() outline.SetInputConnection(reader.GetOutputPort()) outline_mapper = vtk.vtkPolyDataMapper() outline_mapper.SetInputConnection(outline.GetOutputPort()) outline_actor = vtk.vtkActor() outline_actor.SetMapper(outline_mapper) # Define actor properties (color, shading, line width, etc) outline_actor.GetProperty().SetColor(0.0, 0.0, 1.0) outline_actor.GetProperty().SetLineWidth(2.0) outline_actor.GetProperty().SetColor(0.8, 0.8, 0.8) outline_actor.GetProperty().SetLineWidth(2.0) # color lookup table (an alternative is vtkLookUpTable) lut = vtk.vtkColorTransferFunction() lut.AddRGBPoint(0, 1, 0, 0) lut.AddRGBPoint(0.5, 1, 1, 0)
aCellArray = vtk.vtkCellArray() boundary = vtk.vtkPolyData() boundary.SetPoints(aPolyData.GetPoints()) boundary.SetPolys(aCellArray) delaunay = vtk.vtkDelaunay2D() if vtk.VTK_MAJOR_VERSION <= 5: delaunay.SetInput(aPolyData.GetOutput()) delaunay.SetSource(boundary) else: delaunay.SetInputData(aPolyData) delaunay.SetSourceData(boundary) delaunay.Update() meshMapper = vtk.vtkPolyDataMapper() meshMapper.SetInputConnection(delaunay.GetOutputPort()) meshActor = vtk.vtkActor() meshActor.SetMapper(meshMapper) meshActor.GetProperty().SetEdgeColor(0, 0, 1) meshActor.GetProperty().SetInterpolationToFlat() meshActor.GetProperty().SetRepresentationToWireframe() boundaryMapper = vtk.vtkPolyDataMapper() if vtk.VTK_MAJOR_VERSION <= 5: boundaryMapper.SetInputConnection(boundary.GetProducerPort()) else: boundaryMapper.SetInputData(boundary) boundaryActor = vtk.vtkActor()
0.0, r[1], 0.0, 0.0, 0.0, r[2])) grid = vtk.vtkUnstructuredGrid() grid.SetPoints(atom_points) grid.GetPointData().SetTensors(tensors) sphere = vtk.vtkSphereSource() sphere.SetPhiResolution(16) sphere.SetThetaResolution(16) ellipsoids = vtk.vtkTensorGlyph() ellipsoids.SetInputData(grid) ellipsoids.SetSourceConnection(sphere.GetOutputPort()) ellMapper = vtk.vtkPolyDataMapper() ellMapper.SetInputConnection(ellipsoids.GetOutputPort()) ellActor = vtk.vtkActor() ellActor.SetMapper(ellMapper) ellActor.GetProperty().SetOpacity(0.3) molecule = vtk.vtkMolecule() for i in range(natoms): s = symbols[i] a = averaged[i] molecule.AppendAtom(s, a[0], a[1], a[2]) for i in range(natoms): a = averaged[i]
def CreateSurfaceFromPolydata(self, polydata, overwrite=False, name=None, colour=None, transparency=None, volume=None, area=None): normals = vtk.vtkPolyDataNormals() normals.SetInputData(polydata) normals.SetFeatureAngle(80) normals.AutoOrientNormalsOn() normals.Update() mapper = vtk.vtkPolyDataMapper() mapper.SetInputData(normals.GetOutput()) mapper.ScalarVisibilityOff() mapper.ImmediateModeRenderingOn() # improve performance actor = vtk.vtkActor() actor.SetMapper(mapper) if overwrite: surface = Surface(index=self.last_surface_index) else: surface = Surface() if not colour: surface.colour = random.choice(const.SURFACE_COLOUR) else: surface.colour = colour surface.polydata = polydata if transparency: surface.transparency = transparency if name: surface.name = name # Append surface into Project.surface_dict proj = prj.Project() if overwrite: proj.ChangeSurface(surface) else: index = proj.AddSurface(surface) surface.index = index self.last_surface_index = index # Set actor colour and transparency actor.GetProperty().SetColor(surface.colour) actor.GetProperty().SetOpacity(1 - surface.transparency) self.actors_dict[surface.index] = actor session = ses.Session() session.ChangeProject() # The following lines have to be here, otherwise all volumes disappear if not volume or not area: triangle_filter = vtk.vtkTriangleFilter() triangle_filter.SetInputData(polydata) triangle_filter.Update() measured_polydata = vtk.vtkMassProperties() measured_polydata.SetInputConnection( triangle_filter.GetOutputPort()) measured_polydata.Update() volume = measured_polydata.GetVolume() area = measured_polydata.GetSurfaceArea() surface.volume = volume surface.area = area print ">>>>", surface.volume else: surface.volume = volume surface.area = area self.last_surface_index = surface.index Publisher.sendMessage('Load surface actor into viewer', actor) Publisher.sendMessage( 'Update surface info in GUI', (surface.index, surface.name, surface.colour, surface.volume, surface.area, surface.transparency)) return surface.index
Plot3D0.SetQFileName(VTK_DATA_ROOT + "/Data/combq.bin") Plot3D0.SetBinaryFile(1) Plot3D0.SetMultiGrid(0) Plot3D0.SetHasByteCount(0) Plot3D0.SetIBlanking(0) Plot3D0.SetTwoDimensionalGeometry(0) Plot3D0.SetForceRead(0) Plot3D0.SetByteOrder(0) Plot3D0.Update() output = Plot3D0.GetOutput().GetBlock(0) Geometry5 = vtk.vtkStructuredGridOutlineFilter() Geometry5.SetInputData(output) Mapper5 = vtk.vtkPolyDataMapper() Mapper5.SetInputConnection(Geometry5.GetOutputPort()) Mapper5.UseLookupTableScalarRangeOn() Mapper5.SetScalarVisibility(0) Mapper5.SetScalarModeToDefault() Actor5 = vtk.vtkActor() Actor5.SetMapper(Mapper5) Actor5.GetProperty().SetRepresentationToSurface() Actor5.GetProperty().SetInterpolationToGouraud() Actor5.GetProperty().SetAmbient(0.15) Actor5.GetProperty().SetDiffuse(0.85) Actor5.GetProperty().SetSpecular(0.1) Actor5.GetProperty().SetSpecularPower(100) Actor5.GetProperty().SetSpecularColor(1, 1, 1) Actor5.GetProperty().SetColor(1, 1, 1)
def load_stl(stl_path, ren, opacity=1., visibility=1, position=False, colour=False, replace=False, user_matrix=np.identity(4)): vtk_colors = vtk.vtkNamedColors() vtk_colors.SetColor("SkinColor", [233, 200, 188, 255]) vtk_colors.SetColor("BkgColor", [51, 77, 102, 255]) reader = vtk.vtkSTLReader() reader.SetFileName(stl_path) reader.Update() poly_normals = vtk.vtkPolyDataNormals() poly_normals.SetInputData(reader.GetOutput()) poly_normals.ConsistencyOn() poly_normals.AutoOrientNormalsOn() poly_normals.SplittingOff() poly_normals.Update() if replace: transx, transy, transz, rotx, roty, rotz = replace # create a transform that rotates the stl source transform = vtk.vtkTransform() transform.PostMultiply() transform.RotateX(rotx) transform.RotateY(roty) transform.RotateZ(rotz) transform.Translate(transx, transy, transz) transform_filt = vtk.vtkTransformPolyDataFilter() transform_filt.SetTransform(transform) transform_filt.SetInputConnection(poly_normals.GetOutputPort()) transform_filt.Update() mapper = vtk.vtkPolyDataMapper() if vtk.VTK_MAJOR_VERSION <= 5: if replace: mapper.SetInput(transform_filt.GetOutput()) else: mapper.SetInput(poly_normals.GetOutput()) else: if replace: mapper.SetInputConnection(transform_filt.GetOutputPort()) else: mapper.SetInputConnection(poly_normals.GetOutputPort()) mapper.ScalarVisibilityOff() actor = vtk.vtkActor() actor.SetMapper(mapper) actor.GetProperty().SetOpacity(opacity) actor.SetVisibility(visibility) if colour: if type(colour) is str: actor.GetProperty().SetDiffuseColor( vtk_colors.GetColor3d("SkinColor")) actor.GetProperty().SetSpecular(.3) actor.GetProperty().SetSpecularPower(20) else: actor.GetProperty().SetColor(colour) if position: actor.SetPosition(position) matrix_vtk = vtk.vtkMatrix4x4() for row in range(0, 4): for col in range(0, 4): matrix_vtk.SetElement(row, col, user_matrix[row, col]) actor.SetUserMatrix(matrix_vtk) # Assign actor to the renderer ren.AddActor(actor) return actor
def CurvaturesDemo(self): # We are going to handle two different sources. # The first source is a superquadric source. torus = vtk.vtkSuperquadricSource() torus.SetCenter(0.0, 0.0, 0.0) torus.SetScale(1.0, 1.0, 1.0) torus.SetPhiResolution(64) torus.SetThetaResolution(64) torus.SetThetaRoundness(1) torus.SetThickness(0.5) torus.SetSize(0.5) torus.SetToroidal(1) # Rotate the torus towards the observer (around the x-axis) torusT = vtk.vtkTransform() torusT.RotateX(55) torusTF = vtk.vtkTransformFilter() torusTF.SetInputConnection(torus.GetOutputPort()) torusTF.SetTransform(torusT) # The quadric is made of strips, so pass it through a triangle filter as # the curvature filter only operates on polys tri = vtk.vtkTriangleFilter() tri.SetInputConnection(torusTF.GetOutputPort()) # The quadric has nasty discontinuities from the way the edges are generated # so let's pass it though a CleanPolyDataFilter and merge any points which # are coincident, or very close cleaner = vtk.vtkCleanPolyData() cleaner.SetInputConnection(tri.GetOutputPort()) cleaner.SetTolerance(0.005) # The next source will be a parametric function rh = vtk.vtkParametricRandomHills() rhFnSrc = vtk.vtkParametricFunctionSource() rhFnSrc.SetParametricFunction(rh) # Now we have the sources, lets put them into a list. sources = list() sources.append(cleaner) sources.append(cleaner) sources.append(rhFnSrc) sources.append(rhFnSrc) # Colour transfer function. ctf = vtk.vtkColorTransferFunction() ctf.SetColorSpaceToDiverging() ctf.AddRGBPoint(0.0, 0.230, 0.299, 0.754) ctf.AddRGBPoint(1.0, 0.706, 0.016, 0.150) cc = list() for i in range(256): cc.append(ctf.GetColor(float(i) / 255.0)) # Lookup table. lut = list() for idx in range(len(sources)): lut.append(vtk.vtkLookupTable()) lut[idx].SetNumberOfColors(256) for i, item in enumerate(cc): lut[idx].SetTableValue(i, item[0], item[1], item[2], 1.0) if idx == 0: lut[idx].SetRange(-10, 10) if idx == 1: lut[idx].SetRange(0, 4) if idx == 2: lut[idx].SetRange(-1, 1) if idx == 3: lut[idx].SetRange(-1, 1) lut[idx].Build() curvatures = list() for idx in range(len(sources)): curvatures.append(vtk.vtkCurvatures()) if idx % 2 == 0: curvatures[idx].SetCurvatureTypeToGaussian() else: curvatures[idx].SetCurvatureTypeToMean() renderers = list() mappers = list() actors = list() textmappers = list() textactors = list() # Create a common text property. textProperty = vtk.vtkTextProperty() textProperty.SetFontSize(10) textProperty.SetJustificationToCentered() names = [ 'Torus - Gaussian Curvature', 'Torus - Mean Curvature', 'Gaussian Curvature', 'Mean Curvature' ] # Link the pipeline together. for idx, item in enumerate(sources): sources[idx].Update() curvatures[idx].SetInputConnection(sources[idx].GetOutputPort()) mappers.append(vtk.vtkPolyDataMapper()) mappers[idx].SetInputConnection(curvatures[idx].GetOutputPort()) mappers[idx].SetLookupTable(lut[idx]) mappers[idx].SetUseLookupTableScalarRange(1) actors.append(vtk.vtkActor()) actors[idx].SetMapper(mappers[idx]) textmappers.append(vtk.vtkTextMapper()) textmappers[idx].SetInput(names[idx]) textmappers[idx].SetTextProperty(textProperty) textactors.append(vtk.vtkActor2D()) textactors[idx].SetMapper(textmappers[idx]) textactors[idx].SetPosition(150, 16) renderers.append(vtk.vtkRenderer()) gridDimensions = 2 for idx in range(len(sources)): if idx < gridDimensions * gridDimensions: renderers.append(vtk.vtkRenderer) rendererSize = 300 # Create the RenderWindow # renderWindow = vtk.vtkRenderWindow() renderWindow.SetSize(rendererSize * gridDimensions, rendererSize * gridDimensions) # Add and position the renders to the render window. viewport = list() for row in range(gridDimensions): for col in range(gridDimensions): idx = row * gridDimensions + col viewport[:] = [] viewport.append( float(col) * rendererSize / (gridDimensions * rendererSize)) viewport.append( float(gridDimensions - (row + 1)) * rendererSize / (gridDimensions * rendererSize)) viewport.append( float(col + 1) * rendererSize / (gridDimensions * rendererSize)) viewport.append( float(gridDimensions - row) * rendererSize / (gridDimensions * rendererSize)) if idx > (len(sources) - 1): continue renderers[idx].SetViewport(viewport) renderWindow.AddRenderer(renderers[idx]) renderers[idx].AddActor(actors[idx]) renderers[idx].AddActor(textactors[idx]) renderers[idx].SetBackground(0.4, 0.3, 0.2) interactor = vtk.vtkRenderWindowInteractor() interactor.SetRenderWindow(renderWindow) renderWindow.Render() interactor.Start()
reader = vtk.vtkJPEGReader() reader.SetFileName(VTK_DATA_ROOT + "/Data/beach.jpg") #--------------------------------------------------------- # Do the surface rendering sphereSource = vtk.vtkSphereSource() sphereSource.SetRadius(100) textureSphere = vtk.vtkTextureMapToSphere() textureSphere.SetInputConnection(sphereSource.GetOutputPort()) sphereStripper = vtk.vtkStripper() sphereStripper.SetInputConnection(textureSphere.GetOutputPort()) sphereStripper.SetMaximumLength(5) sphereMapper = vtk.vtkPolyDataMapper() sphereMapper.SetInputConnection(sphereStripper.GetOutputPort()) sphereMapper.ScalarVisibilityOff() sphereTexture = vtk.vtkTexture() sphereTexture.SetInputConnection(reader.GetOutputPort()) sphereProperty = vtk.vtkProperty() # sphereProperty.BackfaceCullingOn() sphere = vtk.vtkActor() sphere.SetMapper(sphereMapper) sphere.SetTexture(sphereTexture) sphere.SetProperty(sphereProperty) #--------------------------------------------------------- ren.AddViewProp(sphere)
sigma_test_list.append(Sigma_test[i, i]) test_points = vtk.vtkPoints() for i in range(len(pt_test_list)): test_points.InsertNextPoint(pt_test_list[i].pt[0], pt_test_list[i].pt[1], pt_test_list[i].pt[2]) test_ptsPolyData = vtk.vtkPolyData() test_ptsPolyData.SetPoints(test_points) test_vertFilter = vtk.vtkVertexGlyphFilter() test_vertFilter.SetInputData(test_ptsPolyData) test_vertFilter.Update() test_ptsMapper = vtk.vtkPolyDataMapper() test_ptsMapper.SetInputData(test_vertFilter.GetOutput()) # Magenta - Gaussian Process test_ptsActor = vtk.vtkActor() test_ptsActor.SetMapper(test_ptsMapper) test_ptsActor.GetProperty().SetPointSize(10) test_ptsActor.GetProperty().SetColor(1, 0, 1) test_ptsActor.GetProperty().SetOpacity(1.0) test_ptsActor.GetProperty().SetRenderPointsAsSpheres(1) ############################################# # There is something wrong with probability # Maybe change it to the confidence interval with 2 sigma #############################################
def render(self, pointsData, scalarsArray, radiusArray, nspecies, colouringOptions, atomScaleFactor, lut, resolution): """ Render the given atoms. """ self._logger.debug("Rendering atoms: shape is '%s', colour by: '%s'", self._shape, colouringOptions.colourBy) # points atomPoints = vtk.vtkPoints() atomPoints.SetData(pointsData.getVTK()) # poly data atomsPolyData = vtk.vtkPolyData() atomsPolyData.SetPoints(atomPoints) atomsPolyData.GetPointData().AddArray(scalarsArray.getVTK()) atomsPolyData.GetPointData().SetScalars(radiusArray.getVTK()) # glyph source atomsGlyphSource = vtk.vtkSphereSource( ) # TODO: depends on self._shape atomsGlyphSource.SetPhiResolution(resolution) atomsGlyphSource.SetThetaResolution(resolution) atomsGlyphSource.SetRadius(1.0) # glyph atomsGlyph = vtk.vtkGlyph3D() if vtk.vtkVersion.GetVTKMajorVersion() <= 5: atomsGlyph.SetSource(atomsGlyphSource.GetOutput()) atomsGlyph.SetInput(atomsPolyData) else: atomsGlyph.SetSourceConnection(atomsGlyphSource.GetOutputPort()) atomsGlyph.SetInputData(atomsPolyData) atomsGlyph.SetScaleFactor(atomScaleFactor) atomsGlyph.SetScaleModeToScaleByScalar() atomsGlyph.ClampingOff() # mapper atomsMapper = vtk.vtkPolyDataMapper() atomsMapper.SetInputConnection(atomsGlyph.GetOutputPort()) atomsMapper.SetLookupTable(lut) atomsMapper.SetScalarModeToUsePointFieldData() atomsMapper.SelectColorArray("colours") utils.setMapperScalarRange(atomsMapper, colouringOptions, nspecies) # glyph mapper # glyphMapper = vtk.vtkGlyph3DMapper() # if vtk.vtkVersion.GetVTKMajorVersion() <= 5: # glyphMapper.SetInputConnection(atomsPolyData.GetProducerPort()) # else: # glyphMapper.SetInputData(atomsPolyData) # glyphMapper.SetSourceConnection(atomsGlyphSource.GetOutputPort()) # glyphMapper.SetScaleFactor(displayOptions.atomScaleFactor) # glyphMapper.SetScaleModeToScaleByMagnitude() # glyphMapper.ClampingOff() # glyphMapper.SetLookupTable(lut) # glyphMapper.SetScalarModeToUsePointFieldData() # glyphMapper.SelectColorArray("colours") # setMapperScalarRange(glyphMapper, colouringOptions, NSpecies) # atomsMapper = glyphMapper # actor atomsActor = vtk.vtkActor() atomsActor.SetMapper(atomsMapper) atomsActor.GetProperty().SetSpecular(0.4) atomsActor.GetProperty().SetSpecularPower(50) # store attributes self._actor = utils.ActorObject(atomsActor) self._data["Points"] = pointsData self._data["Scalars"] = scalarsArray self._data["Radius"] = radiusArray self._data["LUT"] = lut self._data["Scale factor"] = atomScaleFactor
renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren1) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # create cones of varying resolution cone0 = vtk.vtkConeSource() cone0.SetResolution(0) cone1 = vtk.vtkConeSource() cone1.SetResolution(1) cone2 = vtk.vtkConeSource() cone2.SetResolution(2) cone8 = vtk.vtkConeSource() cone8.SetResolution(8) cone8.SetDirection(0, 0, 10) cone8.SetCenter(5, 0, 0) cone0Mapper = vtk.vtkPolyDataMapper() cone0Mapper.SetInputConnection(cone0.GetOutputPort()) cone0Actor = vtk.vtkActor() cone0Actor.SetMapper(cone0Mapper) cone1Mapper = vtk.vtkPolyDataMapper() cone1Mapper.SetInputConnection(cone1.GetOutputPort()) cone1Actor = vtk.vtkActor() cone1Actor.SetMapper(cone1Mapper) cone2Mapper = vtk.vtkPolyDataMapper() cone2Mapper.SetInputConnection(cone2.GetOutputPort()) cone2Actor = vtk.vtkActor() cone2Actor.SetMapper(cone2Mapper) cone8Mapper = vtk.vtkPolyDataMapper() cone8Mapper.SetInputConnection(cone8.GetOutputPort()) cone8Actor = vtk.vtkActor() cone8Actor.SetMapper(cone8Mapper)
print "Range of image: %d--%d" % (a1, b1) filename2 = "ctscan_ez_bin.vtk" reader2 = vtk.vtkStructuredPointsReader() reader2.SetFileName(filename2) reader2.Update() a2, b2 = reader2.GetOutput().GetScalarRange() print "Range of segmented image: %d--%d" % (a2, b2) #Liver liverFilter = vtk.vtkContourFilter() liverFilter.SetInputConnection(reader2.GetOutputPort()) liverFilter.SetValue(0, 255.0) liverMapper = vtk.vtkPolyDataMapper() liverMapper.SetInputConnection(liverFilter.GetOutputPort()) liverMapper.SetScalarRange(0.0, 255.0) lut = vtk.vtkLookupTable() liverMapper.SetLookupTable(lut) lut.SetHueRange(0.10, 0.10) lut.Build() liverActor = vtk.vtkActor() liverActor.SetMapper(liverMapper) #Info Text 1 showInfoText = vtk.vtkTextMapper() showInfoText.SetInput( "Press the following keys to move the planes\nNormal to X: G ; B \nNormal to Y: H ; N\nNormal to Z: J ; M"
def main(): points_reader = PointCloudReader("../0000000000.bin") sphereSource = vtk.vtkSphereSource() sphereSource.SetPhiResolution(30) sphereSource.SetThetaResolution(30) sphereSource.SetCenter(40, 40, 0) sphereSource.SetRadius(20) circleCutter = vtk.vtkCutter() circleCutter.SetInputConnection(points_reader.GetOutputPort()) cutPlane = vtk.vtkPlane() cutPlane.SetOrigin([0, 0, 0]) # cutPlane.SetOrigin(sphereSource.GetCenter()) cutPlane.SetNormal(0, 0, 1) circleCutter.SetCutFunction(cutPlane) stripper = vtk.vtkStripper() stripper.SetInputConnection(circleCutter.GetOutputPort()) stripper.Update() circle = stripper.GetOutput() circle_actor = vtk.vtkActor() circle_mapper = vtk.vtkPolyDataMapper() circle_mapper.SetInputConnection(circleCutter.GetOutputPort()) circle_actor.SetMapper(circle_mapper) polyDataWriter = vtk.vtkXMLPolyDataWriter() polyDataWriter.SetInputData(circle) polyDataWriter.SetFileName("circle.vtp") polyDataWriter.SetCompressorTypeToNone() polyDataWriter.SetDataModeToAscii() polyDataWriter.Write() whiteImage = vtk.vtkImageData() bounds = circle.GetBounds() spacing = [0.5, 0.5, 0.5] whiteImage.SetSpacing(spacing) dim = [0, 0, 0] for i in range(3): dim[i] = math.ceil( (bounds[i * 2 + 1] - bounds[i * 2]) / spacing[i]) + 1 whiteImage.SetDimensions(dim) whiteImage.SetExtent(0, dim[0] - 1, 0, dim[1] - 1, 0, dim[2] - 1) origin = [bounds[0], bounds[1], bounds[2]] whiteImage.SetOrigin(origin) whiteImage.AllocateScalars(vtk.VTK_UNSIGNED_CHAR, 1) inval = 255 outval = 0 count = whiteImage.GetNumberOfPoints() for i in range(count): scalars = whiteImage.GetPointData().GetScalars() # f = vtk.vtkFloatArray() # f.SetV scalars.SetValue(i, inval) extruder = vtk.vtkLinearExtrusionFilter() extruder.SetInputData(circle) extruder.SetScaleFactor(1.) extruder.SetVector(0, 0, 1) extruder.Update() pol2stenc = vtk.vtkPolyDataToImageStencil() pol2stenc.SetTolerance(0) pol2stenc.SetInputConnection(extruder.GetOutputPort()) pol2stenc.SetOutputOrigin(origin) pol2stenc.SetOutputSpacing(spacing) pol2stenc.SetOutputWholeExtent(whiteImage.GetExtent()) pol2stenc.Update() imgstenc = vtk.vtkImageStencil() imgstenc.SetInputData(whiteImage) imgstenc.SetStencilConnection(pol2stenc.GetOutputPort()) imgstenc.ReverseStencilOff() imgstenc.SetBackgroundValue(outval) imgstenc.Update() # mapper = vtk.vtkImageMapper() # mapper.SetInputConnection(imgstenc.GetOutputPort()) imgactor = vtk.vtkImageActor() imgactor.GetMapper().SetInputConnection(imgstenc.GetOutputPort()) renderer = vtk.vtkRenderer() renderer.SetBackground(0.1, 0.2, 0.4) renderer.AddActor(imgactor) renderer.AddActor(circle_actor) # renderer.AddActor(actor) renderWindow = vtk.vtkRenderWindow() renderWindow.AddRenderer(renderer) interactor = vtk.vtkRenderWindowInteractor() interactor.SetRenderWindow(renderWindow) style = vtk.vtkInteractorStyleImage() interactor.SetInteractorStyle(style) renderer.ResetCamera() interactor.Start() imageWriter = vtk.vtkMetaImageWriter() imageWriter.SetFileName("labelImage.mhd") imageWriter.SetInputConnection(imgstenc.GetOutputPort()) imageWriter.Write()
# The cut plane plane = vtk.vtkPlane() plane.SetOrigin(0, 0, 0) plane.SetNormal(0, 0, -1) # Clipper - single sphere with point data clipper1 = vtk.vtkPolyDataPlaneClipper() clipper1.SetInputConnection(ele1.GetOutputPort()) clipper1.SetPlane(plane) clipper1.SetBatchSize(10000) clipper1.CappingOn() clipper1.Update() # Display the clipped cells mapper1 = vtk.vtkPolyDataMapper() mapper1.SetInputConnection(clipper1.GetOutputPort()) mapper1.SetScalarRange( clipper1.GetOutput().GetPointData().GetScalars().GetRange()) actor1 = vtk.vtkActor() actor1.SetMapper(mapper1) # Display the cap capMapper1 = vtk.vtkPolyDataMapper() capMapper1.SetInputConnection(clipper1.GetOutputPort(1)) capActor1 = vtk.vtkActor() capActor1.SetMapper(capMapper1) capActor1.GetProperty().SetColor(1, 0, 0)
for i in range(0, tableSize): rgb = list(colorTransferFunction.GetColor(float(i) / tableSize)) + [0.5] lut.SetTableValue(i, rgb) # A plane for the seeds plane = vtk.vtkPlaneSource() plane.SetOrigin(0, 0, 0) plane.SetPoint1(xma, 0, 0) plane.SetPoint2(0, 0, zma) plane.SetXResolution(20) plane.SetYResolution(20) # Add the outline of the plane outline = vtk.vtkOutlineFilter() outline.SetInputData(plane.GetOutput()) outlineMapper = vtk.vtkPolyDataMapper() outlineMapper.SetInputConnection(outline.GetOutputPort()) outlineActor = vtk.vtkActor() outlineActor.SetMapper(outlineMapper) outlineActor.GetProperty().SetColor(1, 1, 1) # Compute streamlines streamline = vtk.vtkStreamTracer() streamline.SetSourceConnection(plane.GetOutputPort()) streamline.SetInputConnection(reader.GetOutputPort()) streamline.SetIntegrationDirectionToForward() #streamline.SetIntegrationDirectionToBackward() #streamline.SetIntegrationDirectionToBoth() streamline.SetMaximumPropagation(1) streamline.SetComputeVorticity(True)
transform1.Scale(1.3, 1.1, 0.8) transform2 = vtk.vtkTransform() transform2.Translate(0.3, 0.7, 0.1) transform2.Scale(1.0, 0.1, 1.8) transformer1 = vtk.vtkTransformPolyDataFilter() transformer1.SetInputConnection(sphere.GetOutputPort()) transformer1.SetTransform(transform1) transformer2 = vtk.vtkTransformPolyDataFilter() transformer2.SetInputConnection(sphere.GetOutputPort()) transformer2.SetTransform(transform2) # map these three shapes into the first renderer map1a = vtk.vtkPolyDataMapper() map1a.SetInputConnection(sphere.GetOutputPort()) Actor1a = vtk.vtkActor() Actor1a.SetMapper(map1a) Actor1a.GetProperty().SetDiffuseColor(1.0000, 0.3882, 0.2784) map1b = vtk.vtkPolyDataMapper() map1b.SetInputConnection(transformer1.GetOutputPort()) Actor1b = vtk.vtkActor() Actor1b.SetMapper(map1b) Actor1b.GetProperty().SetDiffuseColor(0.3882, 1.0000, 0.2784) map1c = vtk.vtkPolyDataMapper() map1c.SetInputConnection(transformer2.GetOutputPort())
def __init__(self, renderer): pm.VtkVisualizer.__init__(self, renderer) # -------- add the beam ---- # geometry self.beam = vtk.vtkCubeSource() self.beam.SetXLength(st.beam_length) self.beam.SetYLength(st.beam_height) self.beam.SetZLength(st.beam_depth) # mapper self.beam_Mapper = vtk.vtkPolyDataMapper() self.beam_Mapper.SetInputConnection(self.beam.GetOutputPort()) # actor self.beam_Actor = vtk.vtkLODActor() self.beam_Actor.SetMapper(self.beam_Mapper) self.beam_Actor.SetPosition( 0, -(st.cart_height / 2 + st.beam_height / 2), 0) # make it look nice self.beam_Prop = self.beam_Actor.GetProperty() # RAL 9007, grey-aluminium self.beam_Prop.SetColor(142 / 255, 142 / 255, 139 / 255) self.ren.AddActor(self.beam_Actor) # -------- add cart ---- # geometry self.cart = vtk.vtkCubeSource() self.cart.SetXLength(st.cart_length) self.cart.SetYLength(st.cart_height) self.cart.SetZLength(st.cart_depth) # mapper self.cart_Mapper = vtk.vtkPolyDataMapper() self.cart_Mapper.SetInputConnection(self.cart.GetOutputPort()) # actor self.cart_Actor = vtk.vtkLODActor() self.cart_Actor.SetPosition(0, 0, 0) self.cart_Actor.RotateWXYZ(0, 1, 0, 0) self.cart_Actor.SetMapper(self.cart_Mapper) # make it look nice self.cart_Prop = self.cart_Actor.GetProperty() # RAL 7011, iron-grey self.cart_Prop.SetColor(64 / 255, 74 / 255, 84 / 255) self.ren.AddActor(self.cart_Actor) # save pose self.cart_pose = [np.array([0, 0, 0]), np.eye(3)] # -------- add axis ---- # geometry self.axis = vtk.vtkCylinderSource() self.axis.SetHeight(st.axis_height) self.axis.SetRadius(st.axis_radius) self.axis.SetResolution(100) # mapper self.axis_Mapper = vtk.vtkPolyDataMapper() self.axis_Mapper.SetInputConnection(self.axis.GetOutputPort()) # actor self.axis_Actor = vtk.vtkLODActor() self.axis_Actor.SetPosition(0, 0, st.cart_depth / 2 + st.axis_height / 2) self.axis_Actor.RotateWXYZ(90, 1, 0, 0) self.axis_Actor.SetMapper(self.axis_Mapper) # make it look nice self.axis_Prop = self.axis_Actor.GetProperty() # RAL 7011, iron-grey self.axis_Prop.SetColor(64 / 255, 74 / 255, 84 / 255) self.ren.AddActor(self.axis_Actor) # save pose self.axis_pose = [ np.array([0, 0, st.cart_depth / 2 + st.axis_height / 2]), pm.rotation_matrix_xyz("x", 90, "deg") ] # -------- add short pendulum ---- # add short pendulum shaft # geometry self.short_pendulum_shaft = vtk.vtkCylinderSource() self.short_pendulum_shaft.SetHeight(st.pendulum_shaft_height) self.short_pendulum_shaft.SetRadius(st.pendulum_shaft_radius) self.short_pendulum_shaft.SetResolution(100) # mapper self.short_pendulum_shaft_Mapper = vtk.vtkPolyDataMapper() self.short_pendulum_shaft_Mapper.SetInputConnection( self.short_pendulum_shaft.GetOutputPort()) # actor self.short_pendulum_shaft_Actor = vtk.vtkLODActor() self.short_pendulum_shaft_Actor.SetPosition( 0, 0, st.cart_depth / 2 + st.axis_height + st.pendulum_shaft_height / 2) self.short_pendulum_shaft_Actor.RotateWXYZ(90, 1, 0, 0) self.short_pendulum_shaft_Actor.SetMapper( self.short_pendulum_shaft_Mapper) # make it look nice self.short_pendulum_shaft_Prop = \ self.short_pendulum_shaft_Actor.GetProperty() # RAL 9007, grey-aluminium, a little bit darker self.short_pendulum_shaft_Prop.SetColor(122 / 255, 122 / 255, 119 / 255) self.ren.AddActor(self.short_pendulum_shaft_Actor) # save pose self.short_pendulum_shaft_pose = [ np.array([ 0, 0, st.cart_depth / 2 + st.axis_height + st.pendulum_shaft_height / 2 ]), pm.rotation_matrix_xyz("x", 90, "deg") ] # add short pendulum # geometry self.short_pendulum = vtk.vtkCylinderSource() self.short_pendulum.SetHeight(st.short_pendulum_height) self.short_pendulum.SetRadius(st.short_pendulum_radius) self.short_pendulum.SetResolution(100) # mapper self.short_pendulum_Mapper = vtk.vtkPolyDataMapper() self.short_pendulum_Mapper.SetInputConnection( self.short_pendulum.GetOutputPort()) # actor self.short_pendulum_Actor = vtk.vtkLODActor() self.short_pendulum_Actor.SetPosition( 0, st.short_pendulum_height / 2, st.cart_depth / 2 + st.axis_height + st.pendulum_shaft_height / 2) self.short_pendulum_Actor.RotateWXYZ(0, 1, 0, 0) self.short_pendulum_Actor.SetMapper(self.short_pendulum_Mapper) # make it look nice self.short_pendulum_Prop = self.short_pendulum_Actor.GetProperty() # RAL 9007, grey-aluminium, a little bit darker self.short_pendulum_Prop.SetColor(122 / 255, 122 / 255, 119 / 255) self.ren.AddActor(self.short_pendulum_Actor) self.short_pendulum_pose = [ np.array([ 0, st.short_pendulum_height / 2, st.cart_depth / 2 + st.axis_height + st.pendulum_shaft_height / 2 ]), np.eye(3) ] # add short pendulum weight # geometry self.short_pendulum_weight = vtk.vtkCylinderSource() self.short_pendulum_weight.SetHeight(st.pendulum_weight_height) self.short_pendulum_weight.SetRadius(st.pendulum_weight_radius) self.short_pendulum_weight.SetResolution(100) # mapper self.short_pendulum_weight_Mapper = vtk.vtkPolyDataMapper() self.short_pendulum_weight_Mapper.SetInputConnection( self.short_pendulum_weight.GetOutputPort()) # actor self.short_pendulum_weight_Actor = vtk.vtkLODActor() self.short_pendulum_weight_Actor.SetPosition( 0, (st.short_pendulum_height + st.pendulum_weight_height / 2), st.cart_depth / 2 + st.axis_height + st.pendulum_shaft_height / 2) self.short_pendulum_weight_Actor.RotateWXYZ(0, 1, 0, 0) self.short_pendulum_weight_Actor.SetMapper( self.short_pendulum_weight_Mapper) # make it look nice self.short_pendulum_weight_Prop \ = self.short_pendulum_weight_Actor.GetProperty() # RAL 9006, white-aluminium self.short_pendulum_weight_Prop.SetColor(162 / 255, 166 / 255, 164 / 255) self.ren.AddActor(self.short_pendulum_weight_Actor) self.short_pendulum_weight_pose = [ np.array([ 0, (st.short_pendulum_height + st.pendulum_weight_height / 2), st.cart_depth / 2 + st.axis_height + st.pendulum_shaft_height / 2 ]), np.eye(3) ] # -------- add long pendulum ---- # add long pendulum shaft # geometry self.long_pendulum_shaft = vtk.vtkCylinderSource() self.long_pendulum_shaft.SetHeight(st.pendulum_shaft_height) self.long_pendulum_shaft.SetRadius(st.pendulum_shaft_radius) self.long_pendulum_shaft.SetResolution(100) # mapper self.long_pendulum_shaft_Mapper = vtk.vtkPolyDataMapper() self.long_pendulum_shaft_Mapper.SetInputConnection( self.long_pendulum_shaft.GetOutputPort()) # actor self.long_pendulum_shaft_Actor = vtk.vtkLODActor() self.long_pendulum_shaft_Actor.SetPosition( 0, 0, st.cart_depth / 2 + st.axis_height + st.pendulum_shaft_height + st.pendulum_shaft_height / 2) self.long_pendulum_shaft_Actor.RotateWXYZ(90, 1, 0, 0) self.long_pendulum_shaft_Actor.SetMapper( self.long_pendulum_shaft_Mapper) # make it look nice self.long_pendulum_shaft_Prop =\ self.long_pendulum_shaft_Actor.GetProperty() # RAL 9007, grey-aluminium self.long_pendulum_shaft_Prop.SetColor(142 / 255, 142 / 255, 139 / 255) self.ren.AddActor(self.long_pendulum_shaft_Actor) # save pose self.long_pendulum_shaft_pose = [ np.array([ 0, 0, st.cart_depth / 2 + st.axis_height + st.pendulum_shaft_height + st.pendulum_shaft_height / 2 ]), pm.rotation_matrix_xyz("x", 90, "deg") ] # add long pendulum # geometry self.long_pendulum = vtk.vtkCylinderSource() self.long_pendulum.SetHeight(st.long_pendulum_height) self.long_pendulum.SetRadius(st.long_pendulum_radius) self.long_pendulum.SetResolution(100) # mapper self.long_pendulum_Mapper = vtk.vtkPolyDataMapper() self.long_pendulum_Mapper.SetInputConnection( self.long_pendulum.GetOutputPort()) # actor self.long_pendulum_Actor = vtk.vtkLODActor() self.long_pendulum_Actor.SetPosition( 0, st.long_pendulum_height / 2, st.cart_depth / 2 + st.axis_height + st.pendulum_shaft_height + st.pendulum_shaft_height / 2) self.long_pendulum_Actor.RotateWXYZ(0, 1, 0, 0) self.long_pendulum_Actor.SetMapper(self.long_pendulum_Mapper) # make it look nice self.long_pendulum_Prop = self.long_pendulum_Actor.GetProperty() # RAL 9007, grey-aluminium self.long_pendulum_Prop.SetColor(142 / 255, 142 / 255, 139 / 255) self.ren.AddActor(self.long_pendulum_Actor) self.long_pendulum_pose = [ np.array([ 0, st.long_pendulum_height / 2, st.cart_depth / 2 + st.axis_height + st.pendulum_shaft_height + st.pendulum_shaft_height / 2 ]), np.eye(3) ] # add long pendulum weight # geometry self.long_pendulum_weight = vtk.vtkCylinderSource() self.long_pendulum_weight.SetHeight(st.pendulum_weight_height) self.long_pendulum_weight.SetRadius(st.pendulum_weight_radius) self.long_pendulum_weight.SetResolution(100) # mapper self.long_pendulum_weight_Mapper = vtk.vtkPolyDataMapper() self.long_pendulum_weight_Mapper.SetInputConnection( self.long_pendulum_weight.GetOutputPort()) # actor self.long_pendulum_weight_Actor = vtk.vtkLODActor() self.long_pendulum_weight_Actor.SetPosition( 0, st.long_pendulum_height + st.pendulum_weight_height / 2, st.cart_depth / 2 + st.axis_height + st.pendulum_shaft_height + st.pendulum_shaft_height / 2) self.long_pendulum_weight_Actor.RotateWXYZ(0, 1, 0, 0) self.long_pendulum_weight_Actor.SetMapper( self.long_pendulum_weight_Mapper) # make it look nice self.long_pendulum_weight_Prop \ = self.long_pendulum_weight_Actor.GetProperty() # RAL 9006, white-aluminium self.long_pendulum_weight_Prop.SetColor(162 / 255, 166 / 255, 164 / 255) self.ren.AddActor(self.long_pendulum_weight_Actor) self.long_pendulum_weight_pose = [ np.array([ 0, st.long_pendulum_height + st.pendulum_weight_height / 2, st.cart_depth / 2 + st.axis_height + st.pendulum_shaft_height + st.pendulum_shaft_height / 2 ]), np.eye(3) ] # add background self.ren.GradientBackgroundOn() self.ren.SetBackground(228 / 255, 232 / 255, 213 / 255) self.ren.SetBackground2(38 / 255, 139 / 255, 210 / 255) # get everybody into the frame self.ren.ResetCamera() self.ren.GetActiveCamera().Zoom(1.45) self.ren.GetActiveCamera().SetFocalPoint(0, 0, 0) # save this view self.save_camera_pose()
elevation16 = vtk.vtkElevationFilter() elevation16.SetInputConnection(warp16.GetOutputPort()) elevation16.SetLowPoint(0, 0, lo) elevation16.SetHighPoint(0, 0, hi) elevation16.SetScalarRange(lo, hi) elevation16.ReleaseDataFlagOn() normals16 = vtk.vtkPolyDataNormals() normals16.SetInputConnection(elevation16.GetOutputPort()) normals16.SetFeatureAngle(60) normals16.ConsistencyOff() normals16.SplittingOff() normals16.ReleaseDataFlagOn() demMapper16 = vtk.vtkPolyDataMapper() demMapper16.SetInputConnection(normals16.GetOutputPort()) demMapper16.SetScalarRange(lo, hi) demMapper16.SetLookupTable(lut) demMapper16.Update() demActor.AddLODMapper(demMapper16) # Create the RenderWindow, Renderer and both Actors # ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) t = vtk.vtkInteractorStyleTerrain()
def main(): file_name = get_program_parameters() colors = vtk.vtkNamedColors() # Set the background color and plate color. Match those in VTKTextbook.pdf. bkg = map(lambda x: x / 255.0, [65, 99, 149]) bar = map(lambda x: x / 255.0, [255, 160, 140]) colors.SetColor("BkgColor", *bkg) colors.SetColor("PlateColor", *bar) # Read a vtk file # plate = vtk.vtkPolyDataReader() plate.SetFileName(file_name) plate.Update() bounds = [0] * 6 plate.GetOutput().GetBounds(bounds) plate.SetVectorsName("mode2") normals = vtk.vtkPolyDataNormals() normals.SetInputConnection(plate.GetOutputPort()) warp = vtk.vtkWarpVector() warp.SetInputConnection(normals.GetOutputPort()) warp.SetScaleFactor(0.5) color = vtk.vtkVectorDot() color.SetInputConnection(warp.GetOutputPort()) plateMapper = vtk.vtkDataSetMapper() plateMapper.SetInputConnection(warp.GetOutputPort()) plateActor = vtk.vtkActor() plateActor.SetMapper(plateMapper) plateActor.GetProperty().SetColor(colors.GetColor3d("PlateColor")) plateActor.RotateX(-90) # Create the outline. # outline = vtk.vtkOutlineFilter() outline.SetInputConnection(plate.GetOutputPort()) spikeMapper = vtk.vtkPolyDataMapper() spikeMapper.SetInputConnection(outline.GetOutputPort()) outlineActor = vtk.vtkActor() outlineActor.SetMapper(spikeMapper) outlineActor.RotateX(-90) outlineActor.GetProperty().SetColor(colors.GetColor3d("White")) # Create the RenderWindow, Renderer and both Actors # 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(plateActor) ren.AddActor(outlineActor) renWin.SetSize(500, 500) # Render the image. renWin.Render() ren.SetBackground(colors.GetColor3d("BkgColor")) # This closely matches the original illustration. ren.GetActiveCamera().SetPosition(-3.7, 13, 15.5) ren.ResetCameraClippingRange() renWin.Render() iren.Start()
transform = vtk.vtkTransform() transform.RotateX(90) # triangulate the data using the specified transform # del1 = vtk.vtkDelaunay2D() del1.SetInputData(profile) del1.SetTransform(transform) del1.BoundingTriangulationOff() del1.SetTolerance(0.001) del1.SetAlpha(0.0) shrink = vtk.vtkShrinkPolyData() shrink.SetInputConnection(del1.GetOutputPort()) map = vtk.vtkPolyDataMapper() map.SetInputConnection(shrink.GetOutputPort()) triangulation = vtk.vtkActor() triangulation.SetMapper(map) triangulation.GetProperty().SetColor(1, 0, 0) triangulation.GetProperty().BackfaceCullingOn() # Add the actors to the renderer, set the background and size # ren1.AddActor(triangulation) ren1.SetBackground(1, 1, 1) renWin.SetSize(300, 300) renWin.Render()
polys.InsertCellPoint(9) polys.InsertCellPoint(10) pd.SetPoints(pts) pd.SetPolys(polys) transform = vtk.vtkTransform() transform.RotateZ(17) transform.Translate(0.1, 0, 0) xform = vtk.vtkTransformPolyDataFilter() xform.SetInputData(pd) xform.SetTransform(transform) # Rasterize through the renderer mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(xform.GetOutputPort()) actor = vtk.vtkActor() actor.SetMapper(mapper) actor.GetProperty().SetColor(1, 0, 0) renWin.SetSize(50, 50) ren1.AddActor(actor) renWin.Render() renSource = vtk.vtkWindowToImageFilter() renSource.SetInput(renWin) renSource.Update() # This trick decouples the pipeline so that updates
#!/usr/bin/env python import vtk # Sphere sphereSource = vtk.vtkSphereSource() sphereSource.SetCenter(-4.0, 0.0, 0.0) sphereSource.SetRadius(4.0) sphereMapper = vtk.vtkPolyDataMapper() sphereMapper.SetInputConnection(sphereSource.GetOutputPort()) sphereActor = vtk.vtkActor() sphereActor.SetMapper(sphereMapper) # Regular Polygon regularPolygonSource = vtk.vtkRegularPolygonSource() regularPolygonSource.SetCenter(4.0, 0.0, 0.0) regularPolygonSource.SetRadius(4.0) regularPolygonMapper = vtk.vtkPolyDataMapper() regularPolygonMapper.SetInputConnection(regularPolygonSource.GetOutputPort()) regularPolygonActor = vtk.vtkActor() regularPolygonActor.SetMapper(regularPolygonMapper) # A renderer and render window renderer = vtk.vtkRenderer() renderWindow = vtk.vtkRenderWindow() renderWindow.AddRenderer(renderer) # An interactor
def main(): xyzFn, qFn = get_program_parameters() colors = vtk.vtkNamedColors() pl3d = vtk.vtkMultiBlockPLOT3DReader() pl3d.SetXYZFileName(xyzFn) pl3d.SetQFileName(qFn) pl3d.SetScalarFunctionNumber(100) pl3d.SetVectorFunctionNumber(202) pl3d.Update() pl3dOutput = pl3d.GetOutput().GetBlock(0) plane = vtk.vtkStructuredGridGeometryFilter() plane.SetInputData(pl3dOutput) plane.SetExtent(1, 100, 1, 100, 7, 7) lut = vtk.vtkLookupTable() planeMapper = vtk.vtkPolyDataMapper() planeMapper.SetLookupTable(lut) planeMapper.SetInputConnection(plane.GetOutputPort()) planeMapper.SetScalarRange(pl3dOutput.GetScalarRange()) planeActor = vtk.vtkActor() planeActor.SetMapper(planeMapper) # This creates an outline around the data. outline = vtk.vtkStructuredGridOutlineFilter() outline.SetInputData(pl3dOutput) outlineMapper = vtk.vtkPolyDataMapper() outlineMapper.SetInputConnection(outline.GetOutputPort()) outlineActor = vtk.vtkActor() outlineActor.SetMapper(outlineMapper) # Much of the following is commented out. To try different lookup tables, # uncomment the appropriate portions. # # This creates a black to white lut. # lut.SetHueRange(0, 0) # lut.SetSaturationRange(0, 0) # lut.SetValueRange(0.2, 1.0) # This creates a red to blue lut. # lut.SetHueRange(0.0, 0.667) # This creates a blue to red lut. # lut.SetHueRange(0.667, 0.0) # This creates a weird effect. The Build() method causes the lookup table # to allocate memory and create a table based on the correct hue, saturation, # value, and alpha (transparency) range. Here we then manually overwrite the # values generated by the Build() method. lut.SetNumberOfColors(256) lut.SetHueRange(0.0, 0.667) lut.Build() # Create the RenderWindow, Renderer and both Actors. # ren1 = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren1) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # Add the actors to the renderer, set the background and size. # ren1.AddActor(outlineActor) ren1.AddActor(planeActor) ren1.SetBackground(colors.GetColor3d("SlateGray")) ren1.TwoSidedLightingOff() renWin.SetSize(512, 512) iren.Initialize() cam1 = ren1.GetActiveCamera() cam1.SetClippingRange(3.95297, 50) cam1.SetFocalPoint(8.88908, 0.595038, 29.3342) cam1.SetPosition(-12.3332, 31.7479, 41.2387) cam1.SetViewUp(0.060772, -0.319905, 0.945498) iren.Start()
def AddNewActor(self, pubsub_evt): """ Create surface actor, save into project and send it to viewer. """ slice_, mask, surface_parameters = pubsub_evt.data matrix = slice_.matrix filename_img = slice_.matrix_filename spacing = slice_.spacing algorithm = surface_parameters['method']['algorithm'] options = surface_parameters['method']['options'] surface_name = surface_parameters['options']['name'] quality = surface_parameters['options']['quality'] fill_holes = surface_parameters['options']['fill'] keep_largest = surface_parameters['options']['keep_largest'] mode = 'CONTOUR' # 'GRAYSCALE' min_value, max_value = mask.threshold_range colour = mask.colour try: overwrite = surface_parameters['options']['overwrite'] except KeyError: overwrite = False mask.matrix.flush() if quality in const.SURFACE_QUALITY.keys(): imagedata_resolution = const.SURFACE_QUALITY[quality][0] smooth_iterations = const.SURFACE_QUALITY[quality][1] smooth_relaxation_factor = const.SURFACE_QUALITY[quality][2] decimate_reduction = const.SURFACE_QUALITY[quality][3] #if imagedata_resolution: #imagedata = iu.ResampleImage3D(imagedata, imagedata_resolution) pipeline_size = 4 if decimate_reduction: pipeline_size += 1 if (smooth_iterations and smooth_relaxation_factor): pipeline_size += 1 if fill_holes: pipeline_size += 1 if keep_largest: pipeline_size += 1 ## Update progress value in GUI UpdateProgress = vu.ShowProgress(pipeline_size) UpdateProgress(0, _("Creating 3D surface...")) language = ses.Session().language if (prj.Project().original_orientation == const.CORONAL): flip_image = False else: flip_image = True n_processors = multiprocessing.cpu_count() pipe_in, pipe_out = multiprocessing.Pipe() o_piece = 1 piece_size = 2000 n_pieces = int(round(matrix.shape[0] / piece_size + 0.5, 0)) q_in = multiprocessing.Queue() q_out = multiprocessing.Queue() p = [] for i in xrange(n_processors): sp = surface_process.SurfaceProcess( pipe_in, filename_img, matrix.shape, matrix.dtype, mask.temp_file, mask.matrix.shape, mask.matrix.dtype, spacing, mode, min_value, max_value, decimate_reduction, smooth_relaxation_factor, smooth_iterations, language, flip_image, q_in, q_out, algorithm != 'Default', algorithm, imagedata_resolution) p.append(sp) sp.start() for i in xrange(n_pieces): init = i * piece_size end = init + piece_size + o_piece roi = slice(init, end) q_in.put(roi) print "new_piece", roi for i in p: q_in.put(None) none_count = 1 while 1: msg = pipe_out.recv() if (msg is None): none_count += 1 else: UpdateProgress(msg[0] / (n_pieces * pipeline_size), msg[1]) if none_count > n_pieces: break polydata_append = vtk.vtkAppendPolyData() # polydata_append.ReleaseDataFlagOn() t = n_pieces while t: filename_polydata = q_out.get() reader = vtk.vtkXMLPolyDataReader() reader.SetFileName(filename_polydata) # reader.ReleaseDataFlagOn() reader.Update() # reader.GetOutput().ReleaseDataFlagOn() polydata = reader.GetOutput() # polydata.SetSource(None) polydata_append.AddInputData(polydata) del reader del polydata t -= 1 polydata_append.Update() # polydata_append.GetOutput().ReleaseDataFlagOn() polydata = polydata_append.GetOutput() #polydata.Register(None) # polydata.SetSource(None) del polydata_append if algorithm == 'ca_smoothing': normals = vtk.vtkPolyDataNormals() normals_ref = weakref.ref(normals) normals_ref().AddObserver( "ProgressEvent", lambda obj, evt: UpdateProgress( normals_ref(), _("Creating 3D surface..."))) normals.SetInputData(polydata) # normals.ReleaseDataFlagOn() #normals.SetFeatureAngle(80) #normals.AutoOrientNormalsOn() normals.ComputeCellNormalsOn() # normals.GetOutput().ReleaseDataFlagOn() normals.Update() del polydata polydata = normals.GetOutput() # polydata.SetSource(None) del normals clean = vtk.vtkCleanPolyData() # clean.ReleaseDataFlagOn() # clean.GetOutput().ReleaseDataFlagOn() clean_ref = weakref.ref(clean) clean_ref().AddObserver( "ProgressEvent", lambda obj, evt: UpdateProgress( clean_ref(), _("Creating 3D surface..."))) clean.SetInputData(polydata) clean.PointMergingOn() clean.Update() del polydata polydata = clean.GetOutput() # polydata.SetSource(None) del clean try: polydata.BuildLinks() except TypeError: polydata.BuildLinks(0) polydata = ca_smoothing.ca_smoothing(polydata, options['angle'], options['max distance'], options['min weight'], options['steps']) # polydata.SetSource(None) # polydata.DebugOn() else: #smoother = vtk.vtkWindowedSincPolyDataFilter() smoother = vtk.vtkSmoothPolyDataFilter() smoother_ref = weakref.ref(smoother) smoother_ref().AddObserver( "ProgressEvent", lambda obj, evt: UpdateProgress( smoother_ref(), _("Creating 3D surface..."))) smoother.SetInputData(polydata) smoother.SetNumberOfIterations(smooth_iterations) smoother.SetRelaxationFactor(smooth_relaxation_factor) smoother.SetFeatureAngle(80) #smoother.SetEdgeAngle(90.0) #smoother.SetPassBand(0.1) smoother.BoundarySmoothingOn() smoother.FeatureEdgeSmoothingOn() #smoother.NormalizeCoordinatesOn() #smoother.NonManifoldSmoothingOn() # smoother.ReleaseDataFlagOn() # smoother.GetOutput().ReleaseDataFlagOn() smoother.Update() del polydata polydata = smoother.GetOutput() #polydata.Register(None) # polydata.SetSource(None) del smoother if decimate_reduction: print "Decimating", decimate_reduction decimation = vtk.vtkQuadricDecimation() # decimation.ReleaseDataFlagOn() decimation.SetInputData(polydata) decimation.SetTargetReduction(decimate_reduction) decimation_ref = weakref.ref(decimation) decimation_ref().AddObserver( "ProgressEvent", lambda obj, evt: UpdateProgress( decimation_ref(), _("Creating 3D surface..."))) #decimation.PreserveTopologyOn() #decimation.SplittingOff() #decimation.BoundaryVertexDeletionOff() # decimation.GetOutput().ReleaseDataFlagOn() decimation.Update() del polydata polydata = decimation.GetOutput() #polydata.Register(None) # polydata.SetSource(None) del decimation to_measure = polydata #to_measure.Register(None) # to_measure.SetSource(None) if keep_largest: conn = vtk.vtkPolyDataConnectivityFilter() conn.SetInputData(polydata) conn.SetExtractionModeToLargestRegion() conn_ref = weakref.ref(conn) conn_ref().AddObserver( "ProgressEvent", lambda obj, evt: UpdateProgress( conn_ref(), _("Creating 3D surface..."))) conn.Update() # conn.GetOutput().ReleaseDataFlagOn() del polydata polydata = conn.GetOutput() #polydata.Register(None) # polydata.SetSource(None) del conn #Filter used to detect and fill holes. Only fill boundary edges holes. #TODO: Hey! This piece of code is the same from #polydata_utils.FillSurfaceHole, we need to review this. if fill_holes: filled_polydata = vtk.vtkFillHolesFilter() # filled_polydata.ReleaseDataFlagOn() filled_polydata.SetInputData(polydata) filled_polydata.SetHoleSize(300) filled_polydata_ref = weakref.ref(filled_polydata) filled_polydata_ref().AddObserver( "ProgressEvent", lambda obj, evt: UpdateProgress( filled_polydata_ref(), _("Creating 3D surface..."))) filled_polydata.Update() # filled_polydata.GetOutput().ReleaseDataFlagOn() del polydata polydata = filled_polydata.GetOutput() #polydata.Register(None) # polydata.SetSource(None) # polydata.DebugOn() del filled_polydata normals = vtk.vtkPolyDataNormals() # normals.ReleaseDataFlagOn() normals_ref = weakref.ref(normals) normals_ref().AddObserver( "ProgressEvent", lambda obj, evt: UpdateProgress( normals_ref(), _("Creating 3D surface..."))) normals.SetInputData(polydata) normals.SetFeatureAngle(80) normals.AutoOrientNormalsOn() # normals.GetOutput().ReleaseDataFlagOn() normals.Update() del polydata polydata = normals.GetOutput() #polydata.Register(None) # polydata.SetSource(None) del normals # Improve performance stripper = vtk.vtkStripper() # stripper.ReleaseDataFlagOn() stripper_ref = weakref.ref(stripper) stripper_ref().AddObserver( "ProgressEvent", lambda obj, evt: UpdateProgress( stripper_ref(), _("Creating 3D surface..."))) stripper.SetInputData(polydata) stripper.PassThroughCellIdsOn() stripper.PassThroughPointIdsOn() # stripper.GetOutput().ReleaseDataFlagOn() stripper.Update() del polydata polydata = stripper.GetOutput() #polydata.Register(None) # polydata.SetSource(None) del stripper # Map polygonal data (vtkPolyData) to graphics primitives. mapper = vtk.vtkPolyDataMapper() mapper.SetInputData(polydata) mapper.ScalarVisibilityOff() # mapper.ReleaseDataFlagOn() mapper.ImmediateModeRenderingOn() # improve performance # Represent an object (geometry & properties) in the rendered scene actor = vtk.vtkActor() actor.SetMapper(mapper) del mapper #Create Surface instance if overwrite: surface = Surface(index=self.last_surface_index) else: surface = Surface(name=surface_name) surface.colour = colour surface.polydata = polydata del polydata # Set actor colour and transparency actor.GetProperty().SetColor(colour) actor.GetProperty().SetOpacity(1 - surface.transparency) prop = actor.GetProperty() interpolation = int(ses.Session().surface_interpolation) prop.SetInterpolation(interpolation) proj = prj.Project() if overwrite: proj.ChangeSurface(surface) else: index = proj.AddSurface(surface) surface.index = index self.last_surface_index = index session = ses.Session() session.ChangeProject() # The following lines have to be here, otherwise all volumes disappear measured_polydata = vtk.vtkMassProperties() # measured_polydata.ReleaseDataFlagOn() measured_polydata.SetInputData(to_measure) volume = float(measured_polydata.GetVolume()) area = float(measured_polydata.GetSurfaceArea()) surface.volume = volume surface.area = area self.last_surface_index = surface.index del measured_polydata del to_measure Publisher.sendMessage('Load surface actor into viewer', actor) # Send actor by pubsub to viewer's render if overwrite and self.actors_dict.keys(): old_actor = self.actors_dict[self.last_surface_index] Publisher.sendMessage('Remove surface actor from viewer', old_actor) # Save actor for future management tasks self.actors_dict[surface.index] = actor Publisher.sendMessage( 'Update surface info in GUI', (surface.index, surface.name, surface.colour, surface.volume, surface.area, surface.transparency)) #When you finalize the progress. The bar is cleaned. UpdateProgress = vu.ShowProgress(1) UpdateProgress(0, _("Ready")) Publisher.sendMessage('Update status text in GUI', _("Ready")) Publisher.sendMessage('End busy cursor') del actor