def __init__(self, amt, radius): Model.__init__(self) self.source = vtk.vtkAppendPolyData() for i in range(amt): opX = 1.0 opY = 1.0 opZ = 1.0 if random() > 0.5: opX *= -1.0 if random() > 0.5: opY *= -1.0 if random() > 0.5: opZ *= -1.0 sRad = 0.25 + ( random() * 0.25 ) x = float(random() * radius) * opX y = float(random() * radius) * opY z = float(random() * radius) * opZ s = vtk.vtkSphereSource() s.SetCenter(x,y,z) s.SetRadius(float(sRad)) s.Update() self.source.AddInput(s.GetOutput()) #add center s = vtk.vtkSphereSource() s.SetCenter(0.0, 0.0, 0.0) s.SetRadius(0.5) s.Update() self.source.AddInput(s.GetOutput()) self.Update()
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 __init__(self, module_manager): # initialise our base class ModuleBase.__init__(self, module_manager) # what a lame-assed filter, we have to make dummy inputs! # if we don't have a dummy input (but instead a None input) it # bitterly complains when we do a GetOutput() (it needs the input # to know the type of the output) - and GetPolyDataOutput() also # doesn't work. # NB: this does mean that our probeFilter NEEDS a PolyData as # probe geometry! ss = vtk.vtkSphereSource() ss.SetRadius(0) self._dummyInput = ss.GetOutput() #This is also retarded - we (sometimes, see below) need the "padder" #to get the image extent big enough to satisfy the probe filter. #No apparent logical reason, but it throws an exception if we don't. self._padder = vtk.vtkImageConstantPad() self._source = None self._input = None self._probeFilter = vtk.vtkProbeFilter() self._probeFilter.SetInput(self._dummyInput) NoConfigModuleMixin.__init__( self, {'Module (self)' : self, 'vtkProbeFilter' : self._probeFilter}) module_utils.setup_vtk_object_progress(self, self._probeFilter, 'Mapping source on input') self.sync_module_logic_with_config()
def __init__(self,ext_actors=None): #ext_actors is a list of any external vtkActors. #initializations: self.renderer = vtk.vtkRenderer() self.window = vtk.vtkRenderWindow() self.window.SetSize(1000,1000) self.mapper = vtk.vtkPolyDataMapper() self.points = vtk.vtkPoints() self.poly_data = vtk.vtkPolyData() self.glyph3d = vtk.vtkGlyph3D() self.actor = vtk.vtkActor() self.point_s = vtk.vtkPointSource() self.sphere = vtk.vtkSphereSource() self.interactor= vtk.vtkRenderWindowInteractor() self.inter_sty = PdbInteractorStyle() self.axes_actor= vtk.vtkAxesActor() #configurations: self.point_s.SetNumberOfPoints(1) self.sphere.SetRadius(1.0) self.interactor.SetInteractorStyle(self.inter_sty) self.interactor.SetRenderWindow(self.window) self.axes_actor.SetTotalLength(100,100,100) if ext_actors: self.ex_actors = ext_actors else: self.ex_actors=[]
def __init__(self, profile=0, radius=2): if not radius: self.radius = Globals.renderProps["sphereSize"] * 1.1 else: self.radius = radius self.z = 0 self.data = vtk.vtkPolyData() self.sphere = vtk.vtkSphereSource() self.sphere.SetRadius( Globals.referenceSize * self.radius ) self.sphere.SetPhiResolution( Globals.renderProps["spherePhiResolution"] ) self.sphere.SetThetaResolution( Globals.renderProps["sphereThetaResolution"] ) self.glyphPoints = vtk.vtkGlyph3D() self.glyphPoints.SetInput( self.data ) self.glyphPoints.SetSource( self.sphere.GetOutput() ) self.mapper = vtk.vtkPolyDataMapper() self.mapper.SetInputConnection( self.glyphPoints.GetOutputPort() ) self.actor = vtk.vtkActor() self.actor.SetMapper(self.mapper) if profile: self.actor.GetProperty().SetColor(0,0,1) else: self.actor.GetProperty().SetColor(1,1,0) Globals.ren.AddActor(self.actor)
def __init__(self): Model.__init__(self) self.source = vtk.vtkSphereSource() self.source.SetCenter(0.0, 0.0, 0.0) self.source.SetRadius(0.5) self.source.Update() self.Update()
def __addVolumeSelectedActor(self, worldpos): # Create a sphere sphereSource = vtk.vtkSphereSource() sphereSource.SetCenter(worldpos) sphereSource.SetRadius(0.5 + self.pick_radius / 2.0) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection( sphereSource.GetOutputPort() ) ren = self.GetRenderWindow().GetRenderers().GetFirstRenderer() if self.actor is not None: #remove old volume selected ren.RemoveActor(self.actor) self.actor = vtk.vtkActor() self.actor.SetMapper(mapper) #prop = vtk.vtkProperty() #prop.ShadingOn() #prop.SetInterpolationToGouraud() #prop.EdgeVisibilityOff() #prop.SetDiffuse(0.7) #prop.SetSpecular(0.4) #prop.SetSpecularPower(20) #prop.SetColor(1.0, 1.0, 0) #prop.SetOpacity(0.5) #self.actor.SetProperty(prop) ren.AddActor(self.actor)
def TestSection_01_GenerateInputData(self): self.inputSegmentationNode = slicer.vtkMRMLSegmentationNode() slicer.mrmlScene.AddNode(self.inputSegmentationNode) # Create new segments import random for segmentName in ['first', 'second', 'third']: sphereSegment = vtkSegmentationCore.vtkSegment() sphereSegment.SetName(segmentName) sphereSegment.SetColor(random.uniform(0.0,1.0), random.uniform(0.0,1.0), random.uniform(0.0,1.0)) sphere = vtk.vtkSphereSource() sphere.SetCenter(random.uniform(0,100),random.uniform(0,100),random.uniform(0,100)) sphere.SetRadius(random.uniform(20,30)) sphere.Update() spherePolyData = sphere.GetOutput() sphereSegment.AddRepresentation( vtkSegmentationCore.vtkSegmentationConverter.GetSegmentationClosedSurfaceRepresentationName(), spherePolyData) self.inputSegmentationNode.GetSegmentation().AddSegment(sphereSegment) self.assertEqual(self.inputSegmentationNode.GetSegmentation().GetNumberOfSegments(), 3)
def main(): '''One render window, multiple viewports''' iren_list = [] rw = vtk.vtkRenderWindow() iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(rw) # Define viewport ranges xmins=[0,.5,0,.5] xmaxs=[0.5,1,0.5,1] ymins=[0,0,.5,.5] ymaxs=[0.5,0.5,1,1] for i in range(4): ren = vtk.vtkRenderer() rw.AddRenderer(ren) ren.SetViewport(xmins[i],ymins[i],xmaxs[i],ymaxs[i]) #Create a sphere sphereSource = vtk.vtkSphereSource() sphereSource.SetCenter(0.0, 0.0, 0.0) sphereSource.SetRadius(5) #Create a mapper and actor mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(sphereSource.GetOutputPort()) actor = vtk.vtkActor() actor.SetMapper(mapper) ren.AddActor(actor) ren.ResetCamera() rw.Render() rw.SetWindowName('RW: Multiple ViewPorts') iren.Start()
def __render_particles(self, particles_dataset): # Data transfer from HDF5 dataset to numpy array for fast access scaling = self.settings.scaling species_id_idx = particles_dataset.dtype.names.index("species_id") position_idx = particles_dataset.dtype.names.index("position") for x in particles_dataset: display_species_id = self.__species_idmap.get(x[species_id_idx]) if display_species_id is None: continue pattr = self.__pattrs.get(display_species_id) if pattr is None: continue pattr = self.settings.pfilter_func(x, display_species_id, pattr) if pattr is not None: sphere = vtk.vtkSphereSource() sphere.SetRadius(scaling * pattr["radius"] / self.__world_size) sphere.SetCenter(scaling * x[position_idx] / self.__world_size) mapper = vtk.vtkPolyDataMapper() mapper.SetInput(sphere.GetOutput()) sphere_actor = vtk.vtkActor() sphere_actor.SetMapper(mapper) sphere_actor.GetProperty().SetColor(pattr["color"]) sphere_actor.GetProperty().SetOpacity(pattr["opacity"]) self.renderer.AddActor(sphere_actor)
def __init__(self, xyz, radius=None, rgb=None): # if radius is not defined, force it to be some percentage of # the total dimensions of the scanz.. if (radius == None): pars = widgets.get_params() if debug: print "pars.dfov is ", pars.dfov if debug: print "pars.dimensions[0] is" , pars.dimensions[0] ratio = float(pars.dfov)/float(pars.dimensions[0]) radius = ratio * 3 if debug: print "setting radius=", radius if rgb is None: rgb = (0,0,1) self.sphere = vtk.vtkSphereSource() self.sphere.SetRadius(radius) res = 20 self.sphere.SetThetaResolution(res) self.sphere.SetPhiResolution(res) self.sphere.SetCenter(xyz) mapper = vtk.vtkPolyDataMapper() mapper.SetInput(self.sphere.GetOutput()) mapper.ImmediateModeRenderingOn() self.SetMapper(mapper) self.GetProperty().SetColor( rgb ) self.label = '' self.labelColor = (1,1,0)
def create_glyphs (self, poly): if self.glyph_type == 'sphere': glyph = vtk.vtkSphereSource() glyph.SetRadius(1) glyph.SetPhiResolution(8) glyph.SetThetaResolution(8) elif self.glyph_type == 'cylinder': glyph = vtk.vtkCylinderSource() glyph.SetHeight(self.height) glyph.SetRadius(self.radius) glyph.SetCenter(0,0,0) glyph.SetResolution(10) glyph.CappingOn() tt = vtk.vtkTransform() tt.RotateZ(90) tf = vtk.vtkTransformPolyDataFilter() tf.SetInput(glyph.GetOutput()) tf.SetTransform(tt) tf.Update() glypher = vtk.vtkGlyph3D() glypher.SetInput(poly) glypher.SetSource(tf.GetOutput()) glypher.SetVectorModeToUseNormal() glypher.SetScaleModeToScaleByScalar() glypher.SetScaleFactor(self.glyph_scale_factor) glypher.Update() return glypher
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 __draw_sphere(self,radius,center,color,resolution=20): source = vtk.vtkSphereSource() source.SetCenter(*center) source.SetRadius(radius) source.SetPhiResolution(resolution) source.SetThetaResolution(resolution) normals = vtk.vtkPolyDataNormals() normals.SetInputConnection(source.GetOutputPort()) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(normals.GetOutputPort()) actor = vtk.vtkActor() actor.SetMapper(mapper) prop = actor.GetProperty() prop.SetColor(color) #prop.SetInterpolationToPhong() brightness = np.max(color) specular_color = np.array(color)/brightness prop.SetSpecularColor(specular_color) prop.SetSpecular(0.1) prop.SetDiffuse(1) prop.SetAmbient(0) info = vtk.vtkInformation() info.Set(vtk.vtkShadowMapBakerPass.RECEIVER(),0) info.Set(vtk.vtkShadowMapBakerPass.OCCLUDER(),0) actor.SetPropertyKeys(info) self.ren.AddActor(actor)
def __init__(self, pos, radius=None, frame=None, scene=None, color='gray'): if radius is None: radius = ArticulationSphere.last_radius_update self.init_radius = radius self.src = vtk.vtkSphereSource() self.src.SetThetaResolution(16) self.src.SetPhiResolution(16) self.src.SetCenter(pos) self.src.SetRadius(radius) self.mapper = vtk.vtkPolyDataMapper() if USING_VTK6: self.mapper.SetInputConnection(self.src.GetOutputPort()) else: self.mapper.SetInput(self.src.GetOutput()) self.actor = vtk.vtkActor() self.actor.SetMapper(self.mapper) self.color = color # base color name self.set_color() self.actor.GetProperty().SetOpacity(0.25) self.frame = frame self.frame.ren.AddActor(self.actor) self.scene = scene self.selected_pts = [] self.is_selected = False if self.scene.point_cloud_selection_enabled: self.select_point_cloud() self.callbacks = defaultdict(lambda: [lambda a: None]) # action_name -> list of callbacks to be called # after action is performed (i.e. 'moved', 'delete', etc) self.polytube_node = None # None -> sphere is "roaming" # (i.e. not attached to any model) self.frame.ren_win.Render()
def VtkDefineActorKPoint(recordGrid, renderer, radius): '''Returns a vtkActor to represent key-points in a rendering scene. It defines the scale, orientation, rendering properties, textures, ... :ivar recordGrid: unstructured grid (generic data set) to which incorporate the actor KPoint :ivar renderer: name of the renderer (lights, views, ...) to be used in the display :ivar radius: radius of the spheres to be employed in the KPoints representation ''' sphereSource= vtk.vtkSphereSource() sphereSource.SetRadius(radius) sphereSource.SetThetaResolution(5) sphereSource.SetPhiResolution(5) markKPts= vtk.vtkGlyph3D() markKPts.SetInputData(recordGrid.uGrid) markKPts.SetSourceData(sphereSource.GetOutput()) markKPts.ScalingOff() markKPts.OrientOff() mappKPts= vtk.vtkPolyDataMapper() mappKPts.SetInputData(markKPts.GetOutput()) visKPts= vtk.vtkActor() visKPts.SetMapper(mappKPts) visKPts.GetProperty().SetColor(.7, .5, .5) renderer.AddActor(visKPts)
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_sphereActor (x, r, rgb, opacity): points = vtk.vtkPoints() points.InsertNextPoint(x[0], x[1], x[2]) diameter = vtk.vtkDoubleArray() diameter.SetNumberOfComponents(1) diameter.InsertNextTuple1(2.0*r) pData = vtk.vtkPolyData() pData.SetPoints(points) pData.GetPointData().SetScalars(diameter) pSource = vtk.vtkSphereSource() pSource.SetPhiResolution(16) pSource.SetThetaResolution(16) pGlyph = vtk.vtkGlyph3D() pGlyph.SetSource(pSource.GetOutput()) pGlyph.SetInput(pData) pGlyph.ScalingOn() pGlyph.SetScaleModeToScaleByScalar() pMapper = vtk.vtkPolyDataMapper() pMapper.ScalarVisibilityOff() pMapper.SetInput(pGlyph.GetOutput()) pActor = vtk.vtkActor() pActor.SetMapper(pMapper) pActor.GetProperty().SetColor(rgb[0], rgb[1], rgb[2]) pActor.GetProperty().SetOpacity(opacity) return pActor
def onApplyButtonClicked(self): """ Real algorithm should be in class VascularWallLogic. """ logging.info("applyButton is clicked.") # Create models for sphere self.sphere = vtk.vtkSphereSource() # Model node model = slicer.vtkMRMLModelNode() model.SetAndObservePolyData(self.sphere.GetOutput()) # Display node self.modelDisplay = slicer.vtkMRMLModelDisplayNode() self.modelDisplay.SetSliceIntersectionVisibility(True) self.modelDisplay.SetVisibility(self.showCheckBox.isChecked()) self.modelDisplay.SetOpacity(0.5) self.modelDisplay.SetRepresentation(1) slicer.mrmlScene.AddNode(self.modelDisplay) model.SetAndObserveDisplayNodeID(self.modelDisplay.GetID()) # Add to scene self.modelDisplay.SetInputPolyDataConnection( model.GetPolyDataConnection()) slicer.mrmlScene.AddNode(model) # Callback self.UpdateSphere(0, 0) self.rulerSelector.currentNode().AddObserver( 'ModifiedEvent', self.UpdateSphere)
def createSampleModelVolume(self, name, color, volumeNode=None): if volumeNode: self.assertTrue( volumeNode.IsA('vtkMRMLScalarVolumeNode') ) bounds = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0] volumeNode.GetRASBounds(bounds) x = (bounds[0] + bounds[1])/2 y = (bounds[2] + bounds[3])/2 z = (bounds[4] + bounds[5])/2 radius = min(bounds[1]-bounds[0],bounds[3]-bounds[2],bounds[5]-bounds[4]) / 3.0 else: radius = 50 x = y = z = 0 # Taken from: http://www.na-mic.org/Bug/view.php?id=1536 sphere = vtk.vtkSphereSource() sphere.SetCenter(x, y, z) sphere.SetRadius(radius) modelNode = slicer.vtkMRMLModelNode() modelNode.SetName(name) modelNode = slicer.mrmlScene.AddNode(modelNode) if vtk.VTK_MAJOR_VERSION <= 5: modelNode.SetAndObservePolyData(sphere.GetOutput()) else: modelNode.SetPolyDataConnection(sphere.GetOutputPort()) modelNode.SetHideFromEditors(0) displayNode = slicer.vtkMRMLModelDisplayNode() slicer.mrmlScene.AddNode(displayNode) displayNode.SliceIntersectionVisibilityOn() displayNode.VisibilityOn() displayNode.SetColor(color[0], color[1], color[2]) modelNode.SetAndObserveDisplayNodeID(displayNode.GetID()) return modelNode
def CreateSphere(radius, color=None): sphereSource = vtkSphereSource() sphereSource.SetRadius(radius) sphereSource.SetThetaResolution(18) sphereSource.SetPhiResolution(18) sphereMapper = vtkPolyDataMapper() sphereMapper.SetInputConnection(sphereSource.GetOutputPort()) sphereActor = vtkActor() sphereActor.PickableOff() sphereActor.SetMapper(sphereMapper) # Give the actor a custom color ColorActor(sphereActor, color) # Also give the sphere object the convenience methods of # SetCenter() and GetCenter() that misses from the vtkActor # class but is present in the vtkSphereSource class def setCenter(x, y, z): sphereSource.SetCenter(x, y, z) def getCenter(): return sphereSource.GetCenter() setattr(sphereActor, "SetCenter", setCenter) setattr(sphereActor, "GetCenter", getCenter) return sphereActor
def SphereSource(self, currentElement): source = vtk.vtkSphereSource() try: source.SetRadius( float(currentElement.get('SetRadius')) ) except: self.logger.error(' .. <SphereSource> failed to SetRadius') if 'SetThetaResolution' in currentElement.keys(): try: source.SetThetaResolution( int(currentElement.get('SetThetaResolution')) ) except: self.logger.error(' .. <SphereSource> failed to SetThetaResolution') if 'SetPhiResolution' in currentElement.keys(): try: source.SetPhiResolution( int(currentElement.get('SetPhiResolution')) ) except: self.logger.error(' .. <SphereSource> failed to SetPhiResolution') if 'SetStartTheta' in currentElement.keys(): try: source.SetStartTheta( float(currentElement.get('SetStartTheta')) ) except: self.logger.error(' .. <SphereSource> failed to SetStartTheta') if 'SetEndTheta' in currentElement.keys(): try: source.SetEndTheta( float(currentElement.get('SetEndTheta')) ) except: self.logger.error(' .. <SphereSource> failed to SetEndTheta') return source
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 drawVtkSymb(symbType,renderer, RGBcolor, vPos, vDir, scale): '''Adds to the renderer a symbol of type 'arrow', 'doubleArrow', 'cone', 'doubleCone', 'sphere', 'doubleSphere','cube' , 'doubleCube', 'cylinder', 'doubleCylinder' :param symbType: type of symbol (available types: 'arrow', 'doubleArrow', 'cone', 'doubleCone', 'sphere', 'doubleSphere','cube' , 'doubleCube', 'cylinder', 'doubleCylinder') :param renderer: vtk renderer :param RGBcolor: list [R,G,B] with the 3 components of color :param vPos: list [x,y,z] with the 3 coordinates of the point where to place the symbol. :param vDir: director vector to orient the symbol :param scale: scale to be applied to the symbol representation ''' symTpLow=symbType.lower() if 'arrow' in symTpLow: symbSource=vtk.vtkArrowSource() elif 'cone' in symTpLow: symbSource=vtk.vtkConeSource() elif 'sphere' in symTpLow: symbSource=vtk.vtkSphereSource() elif 'cube' in symTpLow: symbSource=vtk.vtkCubeSource() elif 'cylinder' in symTpLow: symbSource=vtk.vtkCylinderSource() vPosVx=[vPos[i]-scale/2.0*vDir[i] for i in range(3)] #vertex position addSymb(symbSource,renderer, RGBcolor, vPosVx, vDir, scale) if 'double' in symTpLow: vPosVx=[vPosVx[i]-scale*vDir[i] for i in range(3)] #vertex position addSymb(symbSource,renderer, RGBcolor, vPosVx, vDir, scale)
def CreateSphereMarkers(self, pubsub_evt): ball_id = pubsub_evt.data[0] ballsize = pubsub_evt.data[1] ballcolour = pubsub_evt.data[2] coord = pubsub_evt.data[3] x, y, z = bases.flip_x(coord) ball_ref = vtk.vtkSphereSource() ball_ref.SetRadius(ballsize) ball_ref.SetCenter(x, y, z) mapper = vtk.vtkPolyDataMapper() mapper.SetInput(ball_ref.GetOutput()) prop = vtk.vtkProperty() prop.SetColor(ballcolour) #adding a new actor for the present ball self.staticballs.append(vtk.vtkActor()) self.staticballs[ball_id].SetMapper(mapper) self.staticballs[ball_id].SetProperty(prop) self.ren.AddActor(self.staticballs[ball_id]) ball_id = ball_id + 1 self.UpdateRender()
def PlaneSphereActors(): ps = vtk.vtkPlaneSource() ps.SetXResolution(10) ps.SetYResolution(10) ss = vtk.vtkSphereSource() ss.SetRadius (0.3) group = vtk.vtkMultiBlockDataGroupFilter() group.AddInputConnection(ps.GetOutputPort()) group.AddInputConnection(ss.GetOutputPort()) ag = vtk.vtkRandomAttributeGenerator() ag.SetInputConnection(group.GetOutputPort()) ag.GenerateCellScalarsOn() ag.AttributesConstantPerBlockOn() n = vtk.vtkPolyDataNormals() n.SetInputConnection(ag.GetOutputPort()) n.Update (); actors = [] it = n.GetOutputDataObject(0).NewIterator() it.InitTraversal() while not it.IsDoneWithTraversal(): pm = vtk.vtkPolyDataMapper() pm.SetInputData(it.GetCurrentDataObject()) a = vtk.vtkActor() a.SetMapper(pm) actors.append (a) it.GoToNextItem() return actors
def __init__(self, parent = None): QtGui.QMainWindow.__init__(self, parent) self.frame = QtGui.QFrame() self.vl = QtGui.QVBoxLayout() self.vtkWidget = QVTKRenderWindowInteractor(self.frame) self.vl.addWidget(self.vtkWidget) self.ren = vtk.vtkRenderer() self.vtkWidget.GetRenderWindow().AddRenderer(self.ren) self.iren = self.vtkWidget.GetRenderWindow().GetInteractor() # Create source source = vtk.vtkSphereSource() source.SetCenter(0, 0, 0) source.SetRadius(5.0) # Create a mapper mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(source.GetOutputPort()) # Create an actor actor = vtk.vtkActor() actor.SetMapper(mapper) self.ren.AddActor(actor) self.ren.ResetCamera() self.frame.setLayout(self.vl) self.setCentralWidget(self.frame) self.show() self.iren.Initialize()
def main(): #Create a sphere sphereSource = vtk.vtkSphereSource() sphereSource.SetCenter(0.0, 0.0, 0.0) sphereSource.SetRadius(5) #Create a mapper and actor mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(sphereSource.GetOutputPort()) actor = vtk.vtkActor() actor.SetMapper(mapper) # Setup a renderer, render window, and interactor renderer = vtk.vtkRenderer() renderWindow = vtk.vtkRenderWindow() #renderWindow.SetWindowName("Test") renderWindow.AddRenderer(renderer); renderWindowInteractor = vtk.vtkRenderWindowInteractor() renderWindowInteractor.SetRenderWindow(renderWindow) #Add the actor to the scene renderer.AddActor(actor) renderer.SetBackground(1,1,1) # Background color white #Render and interact renderWindow.Render() #*** SetWindowName after renderWindow.Render() is called*** renderWindow.SetWindowName("Test") renderWindowInteractor.Start()
def __init__(self, xyz, radius, rgb = None, uuid_=None): if rgb is None: rgb = (0, 0, 1) self.sphere = vtk.vtkSphereSource() self.sphere.SetRadius(radius) res = 20 self.sphere.SetThetaResolution(res) self.sphere.SetPhiResolution(res) self.sphere.SetCenter(xyz) mapper = vtk.vtkPolyDataMapper() mapper.SetInput(self.sphere.GetOutput()) mapper.ImmediateModeRenderingOn() self.SetMapper(mapper) self.GetProperty().SetColor( rgb ) self.set_lighting() self.label = '' self.label_color = (1, 1, 0.5) #create ID if not uuid_: self.uuid = uuid.uuid1() else: self.uuid = uuid_
def get_electrode_glyphs(e_pts, e_colors): e_glyph_shape = vtk.vtkSphereSource() # cone.SetResolution(5) # cone.SetHeight(2) e_glyph_shape.SetRadius(3.0) glyphs = vtk.vtkGlyph3D() glyphs.SetSourceConnection(e_glyph_shape.GetOutputPort()) glyphs.SetColorModeToColorByScalar() centroidsPD = vtk.vtkPolyData() centroidsPD.SetPoints(e_pts) centroidsPD.GetPointData().SetScalars(e_colors) if vtk_major_version == 5: glyphs.SetInput(centroidsPD) else: glyphs.SetInputData(centroidsPD) glyphs.ScalingOff() # IMPORTANT glyphs.Update() glyphs.ScalingOff() # IMPORTANT glyphs.Update() return glyphs
#!/usr/bin/env python import vtk # Control the resolution of the test radius = 10.0 res = 4 debug = 0 write = 0 # Create pipeline. Use two sphere sources: # a portion of one sphere imprints on the other. # target = vtk.vtkSphereSource() target.SetRadius(radius) target.SetCenter(0, 0, 0) target.LatLongTessellationOn() target.SetThetaResolution(4 * res) target.SetPhiResolution(4 * res) target.SetStartTheta(0) target.SetEndTheta(90) imprint = vtk.vtkSphereSource() imprint.SetRadius(radius) imprint.SetCenter(0, 0, 0) imprint.LatLongTessellationOn() imprint.SetThetaResolution(8 * res) imprint.SetPhiResolution(4 * res) imprint.SetStartTheta(12) imprint.SetEndTheta(57) imprint.SetStartPhi(60.0) imprint.SetEndPhi(120.0)
def main(): colors = vtk.vtkNamedColors() bkg1 = map(lambda x: x / 255.0, [26, 51, 102]) colors.SetColor("Bkg", *bkg1) # Create the rendering objects. ren1 = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren1) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # Create the pipeline, ball and spikes. sphere = vtk.vtkSphereSource() sphere.SetPhiResolution(7) sphere.SetThetaResolution(7) sphereMapper = vtk.vtkPolyDataMapper() sphereMapper.SetInputConnection(sphere.GetOutputPort()) sphereActor = vtk.vtkActor() sphereActor.SetMapper(sphereMapper) sphereActor2 = vtk.vtkActor() sphereActor2.SetMapper(sphereMapper) cone = vtk.vtkConeSource() cone.SetResolution(5) glyph = vtk.vtkGlyph3D() glyph.SetInputConnection(sphere.GetOutputPort()) glyph.SetSourceConnection(cone.GetOutputPort()) glyph.SetVectorModeToUseNormal() glyph.SetScaleModeToScaleByVector() glyph.SetScaleFactor(0.25) spikeMapper = vtk.vtkPolyDataMapper() spikeMapper.SetInputConnection(glyph.GetOutputPort()) spikeActor = vtk.vtkActor() spikeActor.SetMapper(spikeMapper) spikeActor2 = vtk.vtkActor() spikeActor2.SetMapper(spikeMapper) spikeActor.SetPosition(0, 0.7, 0) sphereActor.SetPosition(0, 0.7, 0) spikeActor2.SetPosition(0, -1.0, -10) sphereActor2.SetPosition(0, -1.0, -10) spikeActor2.SetScale(1.5, 1.5, 1.5) sphereActor2.SetScale(1.5, 1.5, 1.5) ren1.AddActor(sphereActor) ren1.AddActor(spikeActor) ren1.AddActor(sphereActor2) ren1.AddActor(spikeActor2) ren1.SetBackground(colors.GetColor3d("Bkg")) renWin.SetSize(300, 300) # Do the first render and then zoom in a little. renWin.Render() ren1.GetActiveCamera().SetFocalPoint(0, 0, 0.0) ren1.GetActiveCamera().Zoom(1.8) ren1.GetActiveCamera().SetFocalDisk(0.05) renWin.Render() iren.Start()
selectionPoints.InsertPoint(14, 0.436777, 0.0688872, 0.233021) selectionPoints.InsertPoint(15, 0.44874, 0.188852, 0.109882) selectionPoints.InsertPoint(16, 0.391352, 0.254285, 0.176943) selectionPoints.InsertPoint(17, 0.373274, 0.154162, 0.294296) selectionPoints.InsertPoint(18, 0.274659, 0.311654, 0.276609) selectionPoints.InsertPoint(19, 0.206068, 0.31396, 0.329702) selectionPoints.InsertPoint(20, 0.263789, 0.174982, 0.387308) selectionPoints.InsertPoint(21, 0.213034, 0.175485, 0.417142) selectionPoints.InsertPoint(22, 0.169113, 0.261974, 0.390286) selectionPoints.InsertPoint(23, 0.102552, 0.25997, 0.414814) selectionPoints.InsertPoint(24, 0.131512, 0.161254, 0.454705) selectionPoints.InsertPoint(25, 0.000192443, 0.156264, 0.475307) selectionPoints.InsertPoint(26, -0.0392091, 0.000251724, 0.499943) selectionPoints.InsertPoint(27, -0.096161, 0.159646, 0.46438) sphere = vtk.vtkSphereSource() sphere.SetPhiResolution(50) sphere.SetThetaResolution(100) sphere.SetStartPhi(0) sphere.SetEndPhi(90) loop = vtk.vtkSelectPolyData() loop.SetInputConnection(sphere.GetOutputPort()) loop.SetLoop(selectionPoints) loop.GenerateSelectionScalarsOn() # negative scalars inside loop.SetSelectionModeToSmallestRegion() # clips out positive region clip = vtk.vtkClipPolyData() clip.SetInputConnection(loop.GetOutputPort())
def leftButtonPressEvent(self, obj, event): ''' Process left mouse button press. ''' print("leftButtonPressEvent: ") clickPos = self.GetInteractor().GetEventPosition() # vtk.vtkCellPicker() does not select path lines. #picker = vtk.vtkCellPicker() picker = vtk.vtkPropPicker() picker.Pick(clickPos[0], clickPos[1], 0, self.renderer) #picker.SetTolerance(0.0001) if picker.GetActor() == None: return position = picker.GetPickPosition() print(" position: " + str(position)) if self.sphere == None: sphere = vtk.vtkSphereSource() sphere.SetCenter(position[0], position[1], position[2]) sphere.SetRadius(0.1) sphere.Update() polydata = sphere.GetOutput() mapper = vtk.vtkPolyDataMapper() mapper.SetInputData(polydata) mapper.ScalarVisibilityOff() actor = vtk.vtkActor() actor.SetMapper(mapper) actor.GetProperty().SetRepresentationToWireframe() actor.GetProperty().SetColor(0.0, 1.0, 0.0) self.graphics.add_actor(actor) self.sphere = sphere self.sphere.SetCenter(position[0], position[1], position[2]) self.sphere.Update() ## Get path data at the selected point. for path in self.graphics.paths: path_data = path.select(position) print(" path data: ") print(" id: %s" % path_data.id) print(" index: %d" % path_data.index) print(" point: %s" % str(path_data.point)) print(" tangent: %s" % str(path_data.tangent)) print(" rotation: %s" % str(path_data.rotation)) # Show tangent. s = 1.0 pt1 = path_data.point tangent = path_data.tangent tangent = np.array(path_data.tangent) pt2 = [(pt1[j]+s*tangent[j]) for j in range(0,3)] self.graphics.add_line(pt1, pt2, width=5) # Show normal. normal = np.array(path_data.rotation) pt2 = [(pt1[j]+s*normal[j]) for j in range(0,3)] self.graphics.add_line(pt1, pt2, color=[0.0,1.0,0.0], width=5) # Show binormal. binormal = np.cross(tangent, normal) pt2 = [(pt1[j]+s*binormal[j]) for j in range(0,3)] self.graphics.add_line(pt1, pt2, color=[1.0,1.0,0.0], width=5) self.graphics.image.extract_slice(pt1, tangent, normal, binormal) self.graphics.window.Render() return
def testQuadricCut(self): solidTexture = (255, 255) clearTexture = (255, 0) edgeTexture = (0, 255) def makeBooleanTexture(caseNumber, resolution, thickness): #global solidTexture, clearTexture, edgeTexture booleanTexturecaseNumber = vtk.vtkBooleanTexture() booleanTexturecaseNumber.SetXSize(resolution) booleanTexturecaseNumber.SetYSize(resolution) booleanTexturecaseNumber.SetThickness(thickness) if caseNumber == 0: booleanTexturecaseNumber.SetInIn(solidTexture) booleanTexturecaseNumber.SetOutIn(solidTexture) booleanTexturecaseNumber.SetInOut(solidTexture) booleanTexturecaseNumber.SetOutOut(solidTexture) booleanTexturecaseNumber.SetOnOn(solidTexture) booleanTexturecaseNumber.SetOnIn(solidTexture) booleanTexturecaseNumber.SetOnOut(solidTexture) booleanTexturecaseNumber.SetInOn(solidTexture) booleanTexturecaseNumber.SetOutOn(solidTexture) elif caseNumber == 1: booleanTexturecaseNumber.SetInIn(clearTexture) booleanTexturecaseNumber.SetOutIn(solidTexture) booleanTexturecaseNumber.SetInOut(solidTexture) booleanTexturecaseNumber.SetOutOut(solidTexture) booleanTexturecaseNumber.SetOnOn(edgeTexture) booleanTexturecaseNumber.SetOnIn(edgeTexture) booleanTexturecaseNumber.SetOnOut(solidTexture) booleanTexturecaseNumber.SetInOn(edgeTexture) elif caseNumber == 2: booleanTexturecaseNumber.SetInIn(solidTexture) booleanTexturecaseNumber.SetOutIn(clearTexture) booleanTexturecaseNumber.SetInOut(solidTexture) booleanTexturecaseNumber.SetOutOut(solidTexture) booleanTexturecaseNumber.SetOnOn(edgeTexture) booleanTexturecaseNumber.SetOnIn(edgeTexture) booleanTexturecaseNumber.SetOnOut(solidTexture) booleanTexturecaseNumber.SetInOn(solidTexture) booleanTexturecaseNumber.SetOutOn(edgeTexture) elif caseNumber == 3: booleanTexturecaseNumber.SetInIn(clearTexture) booleanTexturecaseNumber.SetOutIn(clearTexture) booleanTexturecaseNumber.SetInOut(solidTexture) booleanTexturecaseNumber.SetOutOut(solidTexture) booleanTexturecaseNumber.SetOnOn(edgeTexture) booleanTexturecaseNumber.SetOnIn(clearTexture) booleanTexturecaseNumber.SetOnOut(solidTexture) booleanTexturecaseNumber.SetInOn(edgeTexture) booleanTexturecaseNumber.SetOutOn(edgeTexture) elif caseNumber == 4: booleanTexturecaseNumber.SetInIn(solidTexture) booleanTexturecaseNumber.SetOutIn(solidTexture) booleanTexturecaseNumber.SetInOut(clearTexture) booleanTexturecaseNumber.SetOutOut(solidTexture) booleanTexturecaseNumber.SetOnOn(edgeTexture) booleanTexturecaseNumber.SetOnIn(solidTexture) booleanTexturecaseNumber.SetOnOut(edgeTexture) booleanTexturecaseNumber.SetInOn(edgeTexture) booleanTexturecaseNumber.SetOutOn(solidTexture) elif caseNumber == 5: booleanTexturecaseNumber.SetInIn(clearTexture) booleanTexturecaseNumber.SetOutIn(solidTexture) booleanTexturecaseNumber.SetInOut(clearTexture) booleanTexturecaseNumber.SetOutOut(solidTexture) booleanTexturecaseNumber.SetOnOn(edgeTexture) booleanTexturecaseNumber.SetOnIn(edgeTexture) booleanTexturecaseNumber.SetOnOut(edgeTexture) booleanTexturecaseNumber.SetInOn(clearTexture) booleanTexturecaseNumber.SetOutOn(solidTexture) elif caseNumber == 6: booleanTexturecaseNumber.SetInIn(solidTexture) booleanTexturecaseNumber.SetOutIn(clearTexture) booleanTexturecaseNumber.SetInOut(clearTexture) booleanTexturecaseNumber.SetOutOut(solidTexture) booleanTexturecaseNumber.SetOnOn(edgeTexture) booleanTexturecaseNumber.SetOnIn(edgeTexture) booleanTexturecaseNumber.SetOnOut(edgeTexture) booleanTexturecaseNumber.SetInOn(edgeTexture) booleanTexturecaseNumber.SetOutOn(edgeTexture) elif caseNumber == 7: booleanTexturecaseNumber.SetInIn(clearTexture) booleanTexturecaseNumber.SetOutIn(clearTexture) booleanTexturecaseNumber.SetInOut(clearTexture) booleanTexturecaseNumber.SetOutOut(solidTexture) booleanTexturecaseNumber.SetOnOn(edgeTexture) booleanTexturecaseNumber.SetOnIn(clearTexture) booleanTexturecaseNumber.SetOnOut(edgeTexture) booleanTexturecaseNumber.SetInOn(clearTexture) booleanTexturecaseNumber.SetOutOn(edgeTexture) elif caseNumber == 8: booleanTexturecaseNumber.SetInIn(solidTexture) booleanTexturecaseNumber.SetOutIn(solidTexture) booleanTexturecaseNumber.SetInOut(solidTexture) booleanTexturecaseNumber.SetOutOut(clearTexture) booleanTexturecaseNumber.SetOnOn(edgeTexture) booleanTexturecaseNumber.SetOnIn(solidTexture) booleanTexturecaseNumber.SetOnOut(edgeTexture) booleanTexturecaseNumber.SetInOn(solidTexture) booleanTexturecaseNumber.SetOutOn(edgeTexture) elif caseNumber == 9: booleanTexturecaseNumber.SetInIn(clearTexture) booleanTexturecaseNumber.SetInOut(solidTexture) booleanTexturecaseNumber.SetOutIn(solidTexture) booleanTexturecaseNumber.SetOutOut(clearTexture) booleanTexturecaseNumber.SetOnOn(edgeTexture) booleanTexturecaseNumber.SetOnIn(edgeTexture) booleanTexturecaseNumber.SetOnOut(edgeTexture) booleanTexturecaseNumber.SetInOn(edgeTexture) booleanTexturecaseNumber.SetOutOn(edgeTexture) elif caseNumber == 10: booleanTexturecaseNumber.SetInIn(solidTexture) booleanTexturecaseNumber.SetInOut(solidTexture) booleanTexturecaseNumber.SetOutIn(clearTexture) booleanTexturecaseNumber.SetOutOut(clearTexture) booleanTexturecaseNumber.SetOnOn(edgeTexture) booleanTexturecaseNumber.SetOnIn(edgeTexture) booleanTexturecaseNumber.SetOnOut(edgeTexture) booleanTexturecaseNumber.SetInOn(solidTexture) booleanTexturecaseNumber.SetOutOn(clearTexture) elif caseNumber == 11: booleanTexturecaseNumber.SetInIn(clearTexture) booleanTexturecaseNumber.SetInOut(solidTexture) booleanTexturecaseNumber.SetOutIn(clearTexture) booleanTexturecaseNumber.SetOutOut(clearTexture) booleanTexturecaseNumber.SetOnOn(edgeTexture) booleanTexturecaseNumber.SetOnIn(clearTexture) booleanTexturecaseNumber.SetOnOut(edgeTexture) booleanTexturecaseNumber.SetInOn(edgeTexture) booleanTexturecaseNumber.SetOutOn(clearTexture) elif caseNumber == 12: booleanTexturecaseNumber.SetInIn(solidTexture) booleanTexturecaseNumber.SetInOut(clearTexture) booleanTexturecaseNumber.SetOutIn(solidTexture) booleanTexturecaseNumber.SetOutOut(clearTexture) booleanTexturecaseNumber.SetOnOn(edgeTexture) booleanTexturecaseNumber.SetOnIn(solidTexture) booleanTexturecaseNumber.SetOnOut(clearTexture) booleanTexturecaseNumber.SetInOn(edgeTexture) booleanTexturecaseNumber.SetOutOn(edgeTexture) elif caseNumber == 13: booleanTexturecaseNumber.SetInIn(clearTexture) booleanTexturecaseNumber.SetInOut(clearTexture) booleanTexturecaseNumber.SetOutIn(solidTexture) booleanTexturecaseNumber.SetOutOut(clearTexture) booleanTexturecaseNumber.SetOnOn(edgeTexture) booleanTexturecaseNumber.SetOnIn(edgeTexture) booleanTexturecaseNumber.SetOnOut(clearTexture) booleanTexturecaseNumber.SetInOn(clearTexture) booleanTexturecaseNumber.SetOutOn(edgeTexture) elif caseNumber == 14: booleanTexturecaseNumber.SetInIn(solidTexture) booleanTexturecaseNumber.SetInOut(clearTexture) booleanTexturecaseNumber.SetOutIn(clearTexture) booleanTexturecaseNumber.SetOutOut(clearTexture) booleanTexturecaseNumber.SetOnOn(edgeTexture) booleanTexturecaseNumber.SetOnIn(edgeTexture) booleanTexturecaseNumber.SetOnOut(clearTexture) booleanTexturecaseNumber.SetInOn(edgeTexture) booleanTexturecaseNumber.SetOutOn(clearTexture) elif caseNumber == 15: booleanTexturecaseNumber.SetInIn(clearTexture) booleanTexturecaseNumber.SetInOut(clearTexture) booleanTexturecaseNumber.SetOutIn(clearTexture) booleanTexturecaseNumber.SetOutOut(clearTexture) booleanTexturecaseNumber.SetOnOn(clearTexture) booleanTexturecaseNumber.SetOnIn(clearTexture) booleanTexturecaseNumber.SetOnOut(clearTexture) booleanTexturecaseNumber.SetInOn(clearTexture) booleanTexturecaseNumber.SetOutOn(clearTexture) booleanTexturecaseNumber.Update() return booleanTexturecaseNumber # A list of positions positions = [] positions.append((-4, 4, 0)) positions.append((-2, 4, 0)) positions.append((0, 4, 0)) positions.append((2, 4, 0)) positions.append((-4, 2, 0)) positions.append((-2, 2, 0)) positions.append((0, 2, 0)) positions.append((2, 2, 0)) positions.append((-4, 0, 0)) positions.append((-2, 0, 0)) positions.append((0, 0, 0)) positions.append((2, 0, 0)) positions.append((-4, -2, 0)) positions.append((-2, -2, 0)) positions.append((0, -2, 0)) positions.append((2, -2, 0)) ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) # define two elliptical cylinders quadric1 = vtk.vtkQuadric() quadric1.SetCoefficients(1, 2, 0, 0, 0, 0, 0, 0, 0, -.07) quadric2 = vtk.vtkQuadric() quadric2.SetCoefficients(2, 1, 0, 0, 0, 0, 0, 0, 0, -.07) # create a sphere for all to use aSphere = vtk.vtkSphereSource() aSphere.SetPhiResolution(50) aSphere.SetThetaResolution(50) # create texture coordinates for all tcoords = vtk.vtkImplicitTextureCoords() tcoords.SetInputConnection(aSphere.GetOutputPort()) tcoords.SetRFunction(quadric1) tcoords.SetSFunction(quadric2) aMapper = vtk.vtkDataSetMapper() aMapper.SetInputConnection(tcoords.GetOutputPort()) # create a mapper, sphere and texture map for each case aTexture = [] anActor = [] for i in range(0, 16): aTexture.append(vtk.vtkTexture()) aTexture[i].SetInputData(makeBooleanTexture(i, 256, 1).GetOutput()) aTexture[i].InterpolateOff() aTexture[i].RepeatOff() anActor.append(vtk.vtkActor()) anActor[i].SetMapper(aMapper) anActor[i].SetTexture(aTexture[i]) anActor[i].SetPosition(positions[i]) anActor[i].SetScale(2.0, 2.0, 2.0) ren.AddActor(anActor[i]) ren.SetBackground(0.4392, 0.5020, 0.5647) ren.ResetCamera() ren.GetActiveCamera().Zoom(1.4) renWin.SetSize(500, 500) # render and interact with data iRen = vtk.vtkRenderWindowInteractor() iRen.SetRenderWindow(renWin); renWin.Render() img_file = "quadricCut.png" vtk.test.Testing.compareImage(iRen.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file), threshold=25) vtk.test.Testing.interact()
def draw_trajectories(fname="orbitsxyz.npy"): # fname: file name of .npy with (x,y,z) of all # points for each trajectory if not fname.endswith(".npy"): fname += ".npy" rays = np.load(fname) points = vtk.vtkPoints() lines = vtk.vtkCellArray() for ray in rays: for point in ray: points.InsertNextPoint(point) # NOTE: This will be the main bottleneck (use vtk c++ if too slow) for i in range(rays.shape[0] * rays.shape[1] - 1): if (i + 1) % (rays.shape[1]) == 0: # do not connect distinct rays continue line = vtk.vtkLine() line.GetPointIds().SetId(0, i) line.GetPointIds().SetId(1, i + 1) lines.InsertNextCell(line) # Configure Sources linesPolyData = vtk.vtkPolyData() linesPolyData.SetPoints(points) linesPolyData.SetLines(lines) sphere = vtk.vtkSphereSource() sphere.SetCenter(0, 0, 0) sphere.SetRadius(radius_bh) sphere.SetPhiResolution(32) sphere.SetThetaResolution(32) # Configure Mappers linesMapper = vtk.vtkPolyDataMapper() linesMapper.SetInputData(linesPolyData) sphereMapper = vtk.vtkPolyDataMapper() sphereMapper.SetInputConnection(sphere.GetOutputPort()) # Configure Actors linesActor = vtk.vtkActor() linesActor.SetMapper(linesMapper) linesActor.GetProperty().SetColor(color_ray) linesActor.GetProperty().SetOpacity(opacity_ray) sphereActor = vtk.vtkActor() sphereActor.SetMapper(sphereMapper) sphereActor.GetProperty().SetOpacity(opacity_bh) sphereActor.GetProperty().SetColor(color_bh) # Configure Renderer ren = vtk.vtkRenderer() window = vtk.vtkRenderWindow() window.AddRenderer(ren) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(window) iren.SetInteractorStyle(vtk.vtkInteractorStyleTrackballCamera()) ren.AddActor(linesActor) ren.AddActor(sphereActor) ren.SetBackground(color_bg) window.SetSize(window_size) # Start iren.Initialize() iren.Start() return
def renderthis(self, warunek): # open a window and create a renderer self.widget.GetRenderWindow().AddRenderer(self.ren) # open file openFileDialog = wx.FileDialog(self, "Open STL file", "", self.filename, "*.stl", wx.FD_OPEN | wx.FD_FILE_MUST_EXIST) if openFileDialog.ShowModal() == wx.ID_CANCEL: return self.filename = openFileDialog.GetPath() # render the data reader = vtk.vtkSTLReader() reader.SetFileName(self.filename) reader.Update() mesh = reader.GetOutput() # To take the polygonal data from the vtkConeSource and # create a rendering for the renderer. coneMapper = vtk.vtkPolyDataMapper() coneMapper.SetInput(reader.GetOutput()) # create an actor for our scene if self.isploted: coneActor = self.ren.GetActors().GetLastActor() self.ren.RemoveActor(coneActor) coneActor = vtk.vtkActor() coneActor.SetMapper(coneMapper) # Add actor self.ren.AddActor(coneActor) # print self.ren.GetActors().GetNumberOfItems() #addPoint(self.ren, pSource, color=[1.0,0.0,0.0]) #addPoint(self.ren, pTarget, color=[1.0,0.0,1.0]) addLine(self.ren, pp1, pp2) addLine(self.ren, pp3, pp4) addLine(self.ren, pp5, pp6) addLine(self.ren, pp7, pp8) addLine(self.ren, pp1, pp7) addLine(self.ren, pp3, pp5) addLine(self.ren, pp4, pp6) addLine(self.ren, pp2, pp8) addLine(self.ren, pp1, pp3) addLine(self.ren, pp7, pp5) addLine(self.ren, pp4, pp2) addLine(self.ren, pp6, pp8) if warunek == 1: addEdges(self.ren) ##################################################################################### featureEdge = vtk.vtkFeatureEdges() featureEdge.FeatureEdgesOff() featureEdge.BoundaryEdgesOn() featureEdge.NonManifoldEdgesOn() featureEdge.SetInput(mesh) featureEdge.Update() openEdges = featureEdge.GetOutput().GetNumberOfCells() if openEdges != 0: print "the stl file is not closed" select = vtk.vtkSelectEnclosedPoints() select.SetSurface(mesh) inside_polydat = vtk.vtkPolyData() forcing_polydat = vtk.vtkPolyData() interpolation_polydat = vtk.vtkPolyData() inside_points = vtk.vtkPoints() forcing_points = vtk.vtkPoints() interpolation_points = vtk.vtkPoints() # for i in range(11): #IsInside(i-5,0.1,0.1,mesh) global licz global licz2 global licznik for j in range(1, lwY + 1): for i in range(1, lwX + 1): licz += 1 print(licz / float(stoProcent)) * 100.0 for k in range(1, lwZ + 1): sprawdzenie = 0 siatkaX[1] = xmin + 0.001 siatkaX[lwX] = xmax - 0.001 siatkaY[1] = ymin + 0.001 siatkaY[lwY] = ymax - 0.001 siatkaZ[1] = zmin + 0.001 siatkaZ[lwZ] = zmax - 0.001 sprawdzenie = IsInsideCheck(siatkaX[i], siatkaY[j], siatkaZ[k], mesh) siatkaX[1] = xmin siatkaX[lwX] = xmax siatkaY[1] = ymin siatkaY[lwY] = ymax siatkaZ[1] = zmin siatkaZ[lwZ] = zmax mesh_point_inside = [siatkaX[i], siatkaY[j], siatkaZ[k]] #mesh_point_forcing = [siatkaX[i]+1.0,siatkaY[j],siatkaZ[k]] maska[licznik] = sprawdzenie licznik = licznik + 1 if sprawdzenie == 1: inside_points.InsertNextPoint(mesh_point_inside) #forcing_points.InsertNextPoint(mesh_point_forcing) licznik = 0 licznik_forcing = 0 for j in range(0, lwY): for i in range(0, lwX): for k in range(0, lwZ): #print j,i,k maska3D[j][i][k] = maska[licznik] licznik = licznik + 1 #print maska3D find_forcing_points(lwY, lwX, lwZ, maska3D, forcing_points, siatkaX, siatkaY, siatkaZ, boundary_points, mesh, intersection, maska3D_forcing, interpolation_points, fnix, fniy, fniz, fncx, fncy, fncz) for j in range(0, lwY): for i in range(0, lwX): for k in range(0, lwZ): if maska3D_forcing[j][i][k] > 0: licznik_forcing = licznik_forcing + maska3D_forcing[j][ i][k] for i in range(0, licznik_forcing): print i, fnix[i], fniy[i], fniz[i], fncx[i], fncy[i], fncz[i] odczyt_STL(self.filename, normals, licznik_forcing, fnix, fniy, fniz, fncx, fncy, fncz) zp = [0, 0, 0] for i in range(0, licznik_forcing): if fncx[i] > 0 and normals[i][0] < 0: normals[i][0] = normals[i][0] * (-1.0) if fncx[i] < 0 and normals[i][0] > 0: normals[i][0] = normals[i][0] * (-1.0) if fncy[i] > 0 and normals[i][1] < 0: normals[i][1] = normals[i][1] * (-1.0) if fncy[i] < 0 and normals[i][1] > 0: normals[i][1] = normals[i][1] * (-1.0) if fncz[i] > 0 and normals[i][2] < 0: normals[i][2] = normals[i][2] * (-1.0) if fncz[i] < 0 and normals[i][2] > 0: normals[i][2] = normals[i][2] * (-1.0) for i in range(0, licznik_forcing): zp1 = [fncx[i], fncy[i], fncz[i]] zp2 = [ normals[i][0] + fncx[i], normals[i][1] + fncy[i], normals[i][2] + fncz[i] ] #normals[i][0]=normals[i][0]+fncx[i] #normals[i][1]=normals[i][1]+fncy[i] #normals[i][2]=normals[i][2]+fncz[i] addLine(self.ren, zp1, zp2) print i, normals[i], zp1, zp2 #print intersection #print "+++++++++++++++++++=" #print maska3D_forcing """ licznik=0 for j in range(0,lwY): for i in range(0,lwX-1): for k in range(0,lwZ): mesh_point_forcing = [siatkaX[i+1],siatkaY[j+1],siatkaZ[k+1]] if (maska3D[j][i][k] == 0) and (maska3D[j][i+1][k] == 1): forcing_points.InsertNextPoint(mesh_point_forcing) licznik=licznik+1 """ zapis = open('Maska.txt', 'w') for i in range(0, lwX * lwY * lwZ): zapis.write(str(maska[i])) zapis.write('\n') zapis.close() print "zapisano Maske" inside_polydat.SetPoints(inside_points) inside = vtk.vtkSphereSource() inside.SetRadius(0.02) inside.SetPhiResolution(8) inside.SetThetaResolution(8) ballGlyph = vtkGlyph3D() ballGlyph.SetColorModeToColorByScalar() ballGlyph.SetSourceConnection(inside.GetOutputPort()) ballGlyph.SetInput(inside_polydat) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(ballGlyph.GetOutputPort()) actor = vtk.vtkActor() actor.SetMapper(mapper) actor.GetProperty().SetColor([1.0, 0.0, 0.0]) self.ren.AddActor(actor) ###################################################################################### forcing_polydat.SetPoints(forcing_points) forcing = vtk.vtkSphereSource() #point.SetCenter(pS) forcing.SetRadius(0.02) forcing.SetPhiResolution(8) forcing.SetThetaResolution(8) forcingGlyph = vtkGlyph3D() forcingGlyph.SetColorModeToColorByScalar() forcingGlyph.SetSourceConnection(forcing.GetOutputPort()) forcingGlyph.SetInput(forcing_polydat) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(forcingGlyph.GetOutputPort()) actor = vtk.vtkActor() actor.SetMapper(mapper) actor.GetProperty().SetColor([0.0, 1.0, 0.0]) self.ren.AddActor(actor) ##################################################################################### """ interpolation_polydat.SetPoints(interpolation_points) interpolation = vtk.vtkSphereSource() #point.SetCenter(pS) interpolation.SetRadius(0.02) interpolation.SetPhiResolution(8) interpolation.SetThetaResolution(8) interpolationGlyph = vtkGlyph3D() interpolationGlyph.SetColorModeToColorByScalar() interpolationGlyph.SetSourceConnection(interpolation.GetOutputPort()) interpolationGlyph.SetInput(interpolation_polydat) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(interpolationGlyph.GetOutputPort()) actor = vtk.vtkActor() actor.SetMapper(mapper) actor.GetProperty().SetColor([0.0,0.0,1.0]) self.ren.AddActor(actor) """ ##################################################################################### obbTree = vtk.vtkOBBTree() obbTree.SetDataSet(mesh) obbTree.BuildLocator() pointsVTKintersection = vtk.vtkPoints() obbTree.IntersectWithLine(pSource, pTarget, pointsVTKintersection, None) pointsVTKIntersectionData = pointsVTKintersection.GetData() noPointsVTKIntersection = pointsVTKIntersectionData.GetNumberOfTuples() pointsIntersection = [] for idx in range(noPointsVTKIntersection): _tup = pointsVTKIntersectionData.GetTuple3(idx) pointsIntersection.append(_tup) print pointsIntersection if not self.isploted: axes = vtk.vtkAxesActor() self.marker = vtk.vtkOrientationMarkerWidget() self.marker.SetInteractor(self.widget._Iren) self.marker.SetOrientationMarker(axes) self.marker.SetViewport(0.75, 0, 1, 0.25) self.marker.SetEnabled(1) self.ren.ResetCamera() self.ren.ResetCameraClippingRange() #cam = self.ren.GetActiveCamera() self.cam.Elevation(50) self.cam.Azimuth(40) #cam.SetPosition(0,0,1) #cam.SetFocalPoint(0,0,-50) self.isploted = True self.ren.Render()
tubes.SetRadius(0.01) tubes.SetNumberOfSides(6) mapEdges = vtk.vtkPolyDataMapper() mapEdges.SetInputConnection(tubes.GetOutputPort()) edgeActor = vtk.vtkActor() edgeActor.SetMapper(mapEdges) edgeActor.GetProperty().SetColor(GetRGBColor('peacock')) edgeActor.GetProperty().SetSpecularColor(1, 1, 1) edgeActor.GetProperty().SetSpecular(0.3) edgeActor.GetProperty().SetSpecularPower(20) edgeActor.GetProperty().SetAmbient(0.2) edgeActor.GetProperty().SetDiffuse(0.8) ball = vtk.vtkSphereSource() ball.SetRadius(0.025) ball.SetThetaResolution(12) ball.SetPhiResolution(12) balls = vtk.vtkGlyph3D() balls.SetInputConnection(apf.GetOutputPort()) balls.SetSourceConnection(ball.GetOutputPort()) mapBalls = vtk.vtkPolyDataMapper() mapBalls.SetInputConnection(balls.GetOutputPort()) ballActor = vtk.vtkActor() ballActor.SetMapper(mapBalls) ballActor.GetProperty().SetColor(GetRGBColor('hot_pink')) ballActor.GetProperty().SetSpecularColor(1, 1, 1)
def main(): sphere_source = vtk.vtkSphereSource() sphere_source.SetCenter(0.0, 0.0, 0.0) sphere_source.SetRadius(5000.0) sphere_source.Update() polydata = sphere_source.GetOutput() # Create a mapper mapper = vtk.vtkPolyDataMapper() #if VTK_MAJOR_VERSION <= 5 #mapper.SetInput(polydata) #else mapper.SetInputData(polydata) #endif # Create an actor actor = vtk.vtkActor() actor.SetMapper(mapper) legend = vtk.vtkLegendBoxActor() legend.SetNumberOfEntries(2) colors = vtk.vtkNamedColors() legend_box = vtk.vtkCubeSource() legend_box.Update() color = [0., 0., 0., 0.] colors.GetColor('tomato', color) legend.SetEntry(0, legend_box.GetOutput(), 'Box', color[:3]) color = [0., 0., 0., 0.] colors.GetColor('banana', color) legend.SetEntry(1, sphere_source.GetOutput(), 'Ball', color[:3]) # place legend in lower right legend.GetPositionCoordinate().SetCoordinateSystemToView() legend.GetPositionCoordinate().SetValue(.5, -1.0) legend.GetPosition2Coordinate().SetCoordinateSystemToView() legend.GetPosition2Coordinate().SetValue(1.0, -0.5) legend.UseBackgroundOn() background = [0., 0., 0., 0.] colors.GetColor('warm_grey', background) legend.SetBackgroundColor(background[:3]) # A renderer and render window renderer = vtk.vtkRenderer() render_window = vtk.vtkRenderWindow() render_window.AddRenderer(renderer) # Add the actors to the scene renderer.AddActor(actor) renderer.AddActor(legend) renderer.SetBackground(0,1,1) # Background color cyan # Render an image (lights and cameras are created automatically) render_window.Render() # An interactor render_window_interactor = vtk.vtkRenderWindowInteractor() render_window_interactor.SetRenderWindow(render_window) # Begin mouse interaction render_window_interactor.Start()
def main(): pixelWidth, pixelHeight = 1920 // 2, 1080 // 2 window_name = 'frame' scn = Scene(pixelHeight, pixelWidth, window_name) # VTK STUFF sphere = vtk.vtkSphereSource() sphere.SetRadius(0.01 / 2) mapper = vtk.vtkPolyDataMapper() if vtk.VTK_MAJOR_VERSION <= 5: mapper.SetInput(sphere.GetOutput()) else: mapper.SetInputConnection(sphere.GetOutputPort()) actors = {} poses = {} dataDir = '/home/biomed/Art/bullet3/data' #p.loadPlugin("eglRendererPlugin") p.loadURDF(os.path.join(dataDir, "plane.urdf"), [0, 0, .4]) # p.loadURDF(os.path.join(dataDir, "r2d2.urdf")) p.configureDebugVisualizer(p.COV_ENABLE_RENDERING, 0) ob = {} count = 0 for i in range(5): for j in range(5): for k in range(5): ob[count] = p.loadURDF(os.path.join( dataDir, "sphere_1cm.urdf"), [ 0.02 * i + np.random.random_sample(1) * 0.02, 0.02 * j + np.random.random_sample(1) * 0.01, 0.02 * k ], useMaximalCoordinates=True) actors[count] = vtk.vtkActor() actors[count].SetMapper(mapper) scn.ren.AddActor(actors[count]) count = count + 1 main_start = time.time() cap = cv2.VideoCapture(0) res = set_res(cap, 1280 // 2, 960 // 2) p.configureDebugVisualizer(p.COV_ENABLE_RENDERING, 1) count = 0 scn.start() while True: ret, frame = cap.read() for k in actors.keys(): pos, rot = p.getBasePositionAndOrientation(ob[k]) actors[k].SetPosition(pos) cv2.imshow(window_name, scn.render(count % 2)) count = count + 1 if cv2.waitKey(1) & 0xFF == ord('q'): play = False break stop = time.time() scn.stop() cap.release() cv2.destroyAllWindows() p.resetSimulation()
def __init__(self, path, fiducialListNode): fids = fiducialListNode scene = slicer.mrmlScene points = vtk.vtkPoints() polyData = vtk.vtkPolyData() polyData.SetPoints(points) lines = vtk.vtkCellArray() polyData.SetLines(lines) linesIDArray = lines.GetData() linesIDArray.Reset() linesIDArray.InsertNextTuple1(0) polygons = vtk.vtkCellArray() polyData.SetPolys(polygons) idArray = polygons.GetData() idArray.Reset() idArray.InsertNextTuple1(0) for point in path: pointIndex = points.InsertNextPoint(*point) linesIDArray.InsertNextTuple1(pointIndex) linesIDArray.SetTuple1(0, linesIDArray.GetNumberOfTuples() - 1) lines.SetNumberOfCells(1) import vtk.util.numpy_support as VN pointsArray = VN.vtk_to_numpy(points.GetData()) self.planePosition, self.planeNormal = self.planeFit(pointsArray.T) # Create model node model = slicer.vtkMRMLModelNode() model.SetScene(scene) model.SetName(scene.GenerateUniqueName("Path-%s" % fids.GetName())) model.SetAndObservePolyData(polyData) # Create display node modelDisplay = slicer.vtkMRMLModelDisplayNode() modelDisplay.SetColor(1, 1, 0) # yellow modelDisplay.SetScene(scene) scene.AddNode(modelDisplay) model.SetAndObserveDisplayNodeID(modelDisplay.GetID()) # Add to scene scene.AddNode(model) # Camera cursor sphere = vtk.vtkSphereSource() sphere.Update() # Create model node cursor = slicer.vtkMRMLModelNode() cursor.SetScene(scene) cursor.SetName(scene.GenerateUniqueName("Cursor-%s" % fids.GetName())) cursor.SetPolyDataConnection(sphere.GetOutputPort()) # Create display node cursorModelDisplay = slicer.vtkMRMLModelDisplayNode() cursorModelDisplay.SetColor(1, 0, 0) # red cursorModelDisplay.SetScene(scene) scene.AddNode(cursorModelDisplay) cursor.SetAndObserveDisplayNodeID(cursorModelDisplay.GetID()) # Add to scene scene.AddNode(cursor) # Create transform node transform = slicer.vtkMRMLLinearTransformNode() transform.SetName( scene.GenerateUniqueName("Transform-%s" % fids.GetName())) scene.AddNode(transform) cursor.SetAndObserveTransformNodeID(transform.GetID()) self.transform = transform
def ani_orbits(fname="orbitsani.npy", record=False, recordfname="movie.ogv"): # fname: file name of .npy with (t,x,y,z) of all # points for each trajectory if not fname.endswith(".npy"): fname += ".npy" data = np.load(fname) rays = data[:, :, 1:] times = data[:, :, 0] points = vtk.vtkPoints() lines = vtk.vtkCellArray() for ray in rays: for point in ray: points.InsertNextPoint(point) # NOTE: This will be the main bottleneck (use vtk c++ if too slow) for i in range(rays.shape[0] * rays.shape[1] - 1): if (i + 1) % (rays.shape[1]) == 0: # do not connect distinct rays continue line = vtk.vtkLine() line.GetPointIds().SetId(0, i) line.GetPointIds().SetId(1, i + 1) lines.InsertNextCell(line) # Configure Sources linesPolyData = vtk.vtkPolyData() linesPolyData.SetPoints(points) linesPolyData.SetLines(lines) sphere = vtk.vtkSphereSource() sphere.SetCenter(0, 0, 0) sphere.SetRadius(radius_bh) sphere.SetPhiResolution(32) sphere.SetThetaResolution(32) # Configure Mappers linesMapper = vtk.vtkPolyDataMapper() linesMapper.SetInputData(linesPolyData) sphereMapper = vtk.vtkPolyDataMapper() sphereMapper.SetInputConnection(sphere.GetOutputPort()) # Configure Actors linesActor = vtk.vtkActor() linesActor.SetMapper(linesMapper) linesActor.GetProperty().SetColor(color_ray) linesActor.GetProperty().SetOpacity(opacity_ray) sphereActor = vtk.vtkActor() sphereActor.SetMapper(sphereMapper) sphereActor.GetProperty().SetOpacity(opacity_bh) sphereActor.GetProperty().SetColor(color_bh) # All of the above, but for stars stars = [Star(rays[i], times[i]) for i in range(rays.shape[0])] # Configure Renderer ren = vtk.vtkRenderer() window = vtk.vtkRenderWindow() window.AddRenderer(ren) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(window) iren.SetInteractorStyle(vtk.vtkInteractorStyleTrackballCamera()) # add actors ren.AddActor(linesActor) ren.AddActor(sphereActor) for s in stars: ren.AddActor(s.actor) ren.SetBackground(color_bg) window.SetSize(window_size) iren.Initialize() # set up timer events star_iter = StarIterator(stars, iren, times.shape[1] - 1, ani_stepsize, record, recordfname) iren.AddObserver('TimerEvent', star_iter.StepForward) iren.CreateRepeatingTimer(ani_framerate) iren.Start() return
def make_vtk_model( filename_input, filename_output ): count = 0 scale = [] color = [] points = [] r_prev = [0,0,0,0] with open(filename_input) as f: for line in f: r = line.split('\t') print( line + "\n") tflag = 0 try: val = float(r[0]) except ValueError: print("text line\n") tflag = 1 if len(r) > 5 and tflag == 0: if r[0]!=r_prev[0] and r[1]!=r_prev[1] and r[2]!=r_prev[2]: count = count + 1 scale.append( float(r[3]) ) color.append( count ) # this could be disease status, etc points.append( [float(r[0]),float(r[1]),float(r[2])] ) r_prev = r print( "Items read:", len( scale )) # output objects outpd = vtk.vtkPolyData() outpoints = vtk.vtkPoints() outpointdata = outpd.GetPointData() out_array = vtk.vtkFloatArray() out_array.SetNumberOfComponents(1) out_array.SetName('ScaleFactor') print( "Point data array created:", out_array.GetName(), out_array.GetNumberOfComponents()) outpointdata.AddArray(out_array) # active array will cause scaling in glyph 3D outpointdata.SetActiveScalars('ScaleFactor') out_array2 = vtk.vtkFloatArray() out_array2.SetNumberOfComponents(1) out_array2.SetName('Color') print( "Point data array created:", out_array2.GetName(), out_array2.GetNumberOfComponents()) outpointdata.AddArray(out_array2) # fill in some data for s, p, c in zip(scale, points, color): out_array.InsertNextValue(s) out_array2.InsertNextValue(c) idx = outpoints.InsertNextPoint(p) print( "Inserted value", out_array.GetValue(idx), out_array.GetTuple(idx), "at:", outpoints.GetPoint(idx)) outpd.SetPoints(outpoints) # save it as visible spheres source1 = vtk.vtkSphereSource() source1.SetRadius(1) source1.Update() source2 = vtk.vtkSphereSource() source2.SetRadius(1.2) source2.Update() appender = vtk.vtkAppendPolyData() appender.AddInputData(source1.GetOutput()) #appender.AddInputData(source2.GetOutput()) appender.Update() glyph = vtk.vtkGlyph3D() glyph.ScalingOn() glyph.SetInputData(outpd) glyph.SetSourceConnection(0, appender.GetOutputPort()) glyph.Update() writer = vtk.vtkPolyDataWriter() writer.SetInputData(glyph.GetOutput()) writer.SetFileName(filename_output) writer.Write() return;
def Execute(self): if self.Surface == None: self.PrintError('Error: No input surface.') if not self.vmtkRenderer: self.vmtkRenderer = vmtkrenderer.vmtkRenderer() self.vmtkRenderer.Initialize() self.OwnRenderer = 1 glyphs = vtk.vtkGlyph3D() glyphSource = vtk.vtkSphereSource() glyphSource.SetRadius(1) glyphs.SetInput(self.Spheres) glyphs.SetSource(glyphSource.GetOutput()) glyphs.SetScaleModeToScaleByScalar() glyphs.SetScaleFactor(1.) glyphMapper = vtk.vtkPolyDataMapper() glyphMapper.SetInput(glyphs.GetOutput()) glyphMapper.ScalarVisibilityOff() self.SpheresActor = vtk.vtkActor() self.SpheresActor.SetMapper(glyphMapper) self.SpheresActor.GetProperty().SetColor(1.0, 0.0, 0.0) self.SpheresActor.GetProperty().SetOpacity(self.Opacity) self.SpheresActor.PickableOff() self.vmtkRenderer.Renderer.AddActor(self.SpheresActor) examineGlyphs = vtk.vtkGlyph3D() examineGlyphSource = vtk.vtkSphereSource() examineGlyphSource.SetRadius(1) examineGlyphs.SetInput(self.ExamineSpheres) examineGlyphs.SetSource(examineGlyphSource.GetOutput()) examineGlyphs.SetScaleModeToScaleByScalar() examineGlyphs.SetScaleFactor(1.) examineGlyphMapper = vtk.vtkPolyDataMapper() examineGlyphMapper.SetInput(examineGlyphs.GetOutput()) examineGlyphMapper.ScalarVisibilityOff() self.ExamineSpheresActor = vtk.vtkActor() self.ExamineSpheresActor.SetMapper(examineGlyphMapper) self.ExamineSpheresActor.GetProperty().SetColor(0.0, 1.0, 0.0) self.ExamineSpheresActor.GetProperty().SetOpacity(self.Opacity) self.ExamineSpheresActor.PickableOff() self.ExamineSpheresActor.VisibilityOff() self.vmtkRenderer.Renderer.AddActor(self.ExamineSpheresActor) self.vmtkRenderer.RenderWindowInteractor.AddObserver( "KeyPressEvent", self.KeyPressed) self.SurfaceMapper = vtk.vtkPolyDataMapper() self.SurfaceMapper.SetInput(self.Surface) self.SurfaceMapper.SetScalarVisibility(self.DisplayArray) surfaceActor = vtk.vtkActor() surfaceActor.SetMapper(self.SurfaceMapper) surfaceActor.GetProperty().SetOpacity(self.Opacity) self.vmtkRenderer.Renderer.AddActor(surfaceActor) self.ScalarBarActor = vtk.vtkScalarBarActor() self.ScalarBarActor.SetLookupTable(self.SurfaceMapper.GetLookupTable()) self.ScalarBarActor.GetLabelTextProperty().ItalicOff() self.ScalarBarActor.GetLabelTextProperty().BoldOff() self.ScalarBarActor.GetLabelTextProperty().ShadowOff() self.ScalarBarActor.SetLabelFormat('%.2f') self.ScalarBarActor.SetTitle('distances') self.ScalarBarActor.VisibilityOff() self.vmtkRenderer.Renderer.AddActor(self.ScalarBarActor) self.SphereWidget = vtk.vtkSphereWidget() self.SphereWidget.SetInteractor( self.vmtkRenderer.RenderWindowInteractor) self.SphereWidget.AddObserver("InteractionEvent", self.SphereCallback) self.ExamineText = vtk.vtkTextActor() self.ExamineText.SetInput("Examine Mode") self.ExamineText.GetPositionCoordinate( ).SetCoordinateSystemToNormalizedViewport() self.ExamineText.SetPosition(0.05, 0.95) self.ExamineText.VisibilityOff() self.vmtkRenderer.Renderer.AddActor2D(self.ExamineText) self.OutputText( 'Please position the mouse and press space to add spheres, \'u\' to undo\n' ) any = 0 while any == 0: self.InitializeSpheres() self.vmtkRenderer.Render() any = self.Spheres.GetNumberOfPoints() self.Surface = self.ComputeDistances() if self.Surface.GetSource(): self.Surface.GetSource().UnRegisterAllOutputs() if self.OwnRenderer: self.vmtkRenderer.Deallocate()
clrs.SetNumberOfComponents(3) clrs.SetName("Colors") clrs.SetNumberOfTuples(0) for i in range(1024): clrs.InsertNextTypedTuple((r, g, b)) return clrs colors = [[int(gr * 255) for gr in c] for c in [ red, orange, yellow, purple, blue, green, white, magenta, green_dark, grey, light_grey, pink ]] # make each point a sphere with small radius for i, val in unique_func.items(): dotSource = vtk.vtkSphereSource() dotSource.SetThetaResolution(5) dotSource.SetPhiResolution(5) dotSource.SetRadius(0.3) dotSource.SetCenter(*i) sp = dotSource.GetOutput() dotSource.Update() sp.GetCellData().SetScalars(get_color(*colors[val])) items.AddInputConnection(dotSource.GetOutputPort()) # settings domainMapper.SetScalarVisibility(0) domainActor.GetProperty().SetOpacity(0.3)
def show(self): cube = vtk.vtkCubeSource() cube.SetCenter(self.volumen.x,self.volumen.y,self.volumen.z) #cube.SetBounds(double xMin, double xMax, double yMin, double yMax, double zMin, double zMax) cube.SetXLength(self.volumen.w*2) cube.SetYLength(self.volumen.h*2) cube.SetZLength(self.volumen.d*2) cube.Update() # Mpear cubeMapper = vtk.vtkPolyDataMapper() cubeMapper.SetInputData(cube.GetOutput()) # Actor. cubeActor = vtk.vtkActor() cubeActor.SetMapper(cubeMapper) cubeActor.GetProperty().SetOpacity(.2); cubeActor.GetProperty().SetColor(colors.GetColor3d("Cornsilk"))#Banana if(self.divided): self.northeastfront.show() print("northeastfront: ",self.northeastfront.points) self.northwestfront.show() print("northwestfront: ",self.northwestfront.points) self.northeastback.show() print("northeastback: ",self.northeastback.points) self.northwestback.show() print("northwestback: ",self.northwestback.points) self.southeastfront.show() print("southeastfront: ",self.southeastfront.points) self.southwestfront.show() print("southwestfront: ",self.southwestfront.points) self.southeastback.show() print("southeastback: ",self.southeastback.points) self.southwestback.show() print("southwestback: ",self.southwestback.points) for i in range(len(self.points)): sphereSource = vtk.vtkSphereSource() xs = self.points[i][0] ys = self.points[i][1] zs = self.points[i][2] sphereSource.SetCenter(xs,ys,zs) sphereSource.SetRadius(10) # Make the surface smooth. sphereSource.SetPhiResolution(100) sphereSource.SetThetaResolution(100) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(sphereSource.GetOutputPort()) actor = vtk.vtkActor() actor.SetMapper(mapper) #prueba para verificar los hijos if(self.divided): actor.GetProperty().SetColor(colors.GetColor3d("Black")) else: actor.GetProperty().SetColor(colors.GetColor3d("Red")) renderer.AddActor(actor) renderer.AddActor(cubeActor)
def testMassProperties(self): # Create the RenderWindow, Renderer and both Actors # ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) cone = vtk.vtkConeSource() cone.SetResolution(50) sphere = vtk.vtkSphereSource() sphere.SetPhiResolution(50) sphere.SetThetaResolution(50) cube = vtk.vtkCubeSource() cube.SetXLength(1) cube.SetYLength(1) cube.SetZLength(1) sphereMapper = vtk.vtkPolyDataMapper() sphereMapper.SetInputConnection(sphere.GetOutputPort()) sphereMapper.GlobalImmediateModeRenderingOn() sphereActor = vtk.vtkActor() sphereActor.SetMapper(sphereMapper) sphereActor.GetProperty().SetDiffuseColor(1, .2, .4) coneMapper = vtk.vtkPolyDataMapper() coneMapper.SetInputConnection(cone.GetOutputPort()) coneMapper.GlobalImmediateModeRenderingOn() coneActor = vtk.vtkActor() coneActor.SetMapper(coneMapper) coneActor.GetProperty().SetDiffuseColor(.2, .4, 1) cubeMapper = vtk.vtkPolyDataMapper() cubeMapper.SetInputConnection(cube.GetOutputPort()) cubeMapper.GlobalImmediateModeRenderingOn() cubeActor = vtk.vtkActor() cubeActor.SetMapper(cubeMapper) cubeActor.GetProperty().SetDiffuseColor(.2, 1, .4) #Add the actors to the renderer, set the background and size # sphereActor.SetPosition(-5, 0, 0) ren.AddActor(sphereActor) coneActor.SetPosition(0, 0, 0) ren.AddActor(coneActor) coneActor.SetPosition(5, 0, 0) ren.AddActor(cubeActor) tf = dict() mp = dict() vt = dict() pdm = dict() ta = dict() def MakeText(primitive): tf.update({primitive: vtk.vtkTriangleFilter()}) tf[primitive].SetInputConnection(primitive.GetOutputPort()) mp.update({primitive: vtk.vtkMassProperties()}) mp[primitive].SetInputConnection(tf[primitive].GetOutputPort()) # here we capture stdout and write it to a variable for processing. summary = StringIO.StringIO() # save the original stdout old_stdout = sys.stdout sys.stdout = summary print mp[primitive] summary = summary.getvalue() startSum = summary.find(" VolumeX") endSum = len(summary) print summary[startSum:] # Restore stdout sys.stdout = old_stdout vt.update({primitive: vtk.vtkVectorText()}) vt[primitive].SetText(summary[startSum:]) pdm.update({primitive: vtk.vtkPolyDataMapper()}) pdm[primitive].SetInputConnection(vt[primitive].GetOutputPort()) ta.update({primitive: vtk.vtkActor()}) ta[primitive].SetMapper(pdm[primitive]) ta[primitive].SetScale(.2, .2, .2) return ta[primitive] ren.AddActor(MakeText(sphere)) ren.AddActor(MakeText(cube)) ren.AddActor(MakeText(cone)) ta[sphere].SetPosition(sphereActor.GetPosition()) ta[sphere].AddPosition(-2, -1, 0) ta[cube].SetPosition(cubeActor.GetPosition()) ta[cube].AddPosition(-2, -1, 0) ta[cone].SetPosition(coneActor.GetPosition()) ta[cone].AddPosition(-2, -1, 0) ren.SetBackground(0.1, 0.2, 0.4) renWin.SetSize(786, 256) # render the image # ren.ResetCamera() cam1 = ren.GetActiveCamera() cam1.Dolly(3) ren.ResetCameraClippingRange() # render and interact with data iRen = vtk.vtkRenderWindowInteractor() iRen.SetRenderWindow(renWin) renWin.Render() img_file = "MassProperties.png" vtk.test.Testing.compareImage( iRen.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file), threshold=25) vtk.test.Testing.interact()
def main(): colors = vtk.vtkNamedColors() # Set the background color. colors.SetColor('bkg', [26, 51, 102, 255]) # The following lines create a sphere represented by polygons. # sphere = vtk.vtkSphereSource() sphere.SetThetaResolution(100) sphere.SetPhiResolution(50) # The mapper is responsible for pushing the geometry into the graphics # library. It may also do color mapping, if scalars or other attributes # are defined. # sphereMapper = vtk.vtkPolyDataMapper() sphereMapper.SetInputConnection(sphere.GetOutputPort()) # The actor is a grouping mechanism: besides the geometry (mapper), it # also has a property, transformation matrix, and/or texture map. # In this example we create eight different spheres (two rows of four # spheres) and set the ambient lighting coefficients. A little ambient # is turned on so the sphere is not completely black on the back side. # numberOfSpheres = 8 spheres = list() ambient = 0.125 diffuse = 0.0 specular = 0.0 position = [0, 0, 0] for i in range(0, numberOfSpheres): spheres.append(vtk.vtkActor()) spheres[i].SetMapper(sphereMapper) spheres[i].GetProperty().SetColor(colors.GetColor3d('Red')) spheres[i].GetProperty().SetAmbient(ambient) spheres[i].GetProperty().SetDiffuse(diffuse) spheres[i].GetProperty().SetSpecular(specular) spheres[i].AddPosition(position) ambient += 0.125 position[0] += 1.25 if i == 3: position[0] = 0 position[1] = 1.25 # Create the graphics structure. The renderer renders into the # render window. The render window interactor captures mouse events # and will perform appropriate camera or actor manipulation # depending on the nature of the events. # 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. # for i in range(0, numberOfSpheres): ren.AddActor(spheres[i]) ren.SetBackground(colors.GetColor3d('bkg')) renWin.SetSize(640, 480) renWin.SetWindowName('AmbientSpheres') # Set up the lighting. # light = vtk.vtkLight() light.SetFocalPoint(1.875, 0.6125, 0) light.SetPosition(0.875, 1.6125, 1) ren.AddLight(light) # We want to eliminate perspective effects on the apparent lighting. # Parallel camera projection will be used. To zoom in parallel projection # mode, the ParallelScale is set. # ren.GetActiveCamera().SetFocalPoint(0, 0, 0) ren.GetActiveCamera().SetPosition(0, 0, 1) ren.GetActiveCamera().SetViewUp(0, 1, 0) ren.GetActiveCamera().ParallelProjectionOn() ren.ResetCamera() ren.GetActiveCamera().SetParallelScale(2.0) # This starts the event loop and invokes an initial render. # iren.Initialize() renWin.Render() iren.Start()
def make_vtk_model(filename_input, filename_output): count = 0 scale = [] color = [] points = [] r_prev = [0, 0, 0, 0] with open(filename_input) as f: for line in f: r = line.split('\t') print line + "\n" while len(r) > 3: try: val = float(r[0]) print "value: " + str(val) break except ValueError: print "no good: " + r[0] del r[0] print "removed: " + r[0] if len(r) > 3: if r[1] <> r_prev[1] and r[2] <> r_prev[2] and r[0] <> r_prev[ 0]: count = count + 1 scale.append(float(r[3])) color.append(count) # this could be disease status, etc points.append([-float(r[0]), float(r[1]), float(r[2])]) r_prev = r print "Items read:", len(scale) # output objects outpd = vtk.vtkPolyData() outpoints = vtk.vtkPoints() outpointdata = outpd.GetPointData() out_array = vtk.vtkFloatArray() out_array.SetNumberOfComponents(1) out_array.SetName('ScaleFactor') print "Point data array created:", out_array.GetName( ), out_array.GetNumberOfComponents() outpointdata.AddArray(out_array) # active array will cause scaling in glyph 3D outpointdata.SetActiveScalars('ScaleFactor') out_array2 = vtk.vtkFloatArray() out_array2.SetNumberOfComponents(1) out_array2.SetName('Color') print "Point data array created:", out_array2.GetName( ), out_array2.GetNumberOfComponents() outpointdata.AddArray(out_array2) # fill in some data for s, p, c in zip(scale, points, color): if s < 15: out_array.InsertNextValue(s) out_array2.InsertNextValue(c) idx = outpoints.InsertNextPoint(p) print "Inserted value", out_array.GetValue( idx), out_array.GetTuple(idx), "at:", outpoints.GetPoint(idx) outpd.SetPoints(outpoints) # save it as visible spheres source1 = vtk.vtkSphereSource() source1.SetRadius(1) source1.SetPhiResolution(30) source1.SetThetaResolution(30) source1.Update() appender = vtk.vtkAppendPolyData() appender.AddInputData(source1.GetOutput()) appender.Update() glyph = vtk.vtkGlyph3D() glyph.ScalingOn() glyph.SetInputData(outpd) glyph.SetSourceConnection(0, appender.GetOutputPort()) glyph.Update() model_display = slicer.mrmlScene.CreateNodeByClass( 'vtkMRMLModelDisplayNode') slicer.mrmlScene.AddNode(model_display) print(model_display.GetID()) model = slicer.mrmlScene.CreateNodeByClass('vtkMRMLModelNode') slicer.mrmlScene.AddNode(model) model.SetAndObserveDisplayNodeID(model_display.GetID()) model.SetAndObservePolyData(source1.GetOutput()) writer = vtk.vtkPolyDataWriter() writer.SetInputData(glyph.GetOutput()) writer.SetFileName(filename_output) writer.Write() return
# Force a starting random value raMath = vtk.vtkMath() raMath.RandomSeed(6) # Generate random attributes on a plane # ps = vtk.vtkPlaneSource() ps.SetXResolution(10) ps.SetYResolution(10) ag = vtk.vtkRandomAttributeGenerator() ag.SetInputConnection(ps.GetOutputPort()) ag.GenerateAllDataOn() ss = vtk.vtkSphereSource() ss.SetPhiResolution(16) ss.SetThetaResolution(32) tg = vtk.vtkTensorGlyph() tg.SetInputConnection(ag.GetOutputPort()) tg.SetSourceConnection(ss.GetOutputPort()) tg.SetScaleFactor(0.1) tg.SetMaxScaleFactor(10) tg.ClampScalingOn() n = vtk.vtkPolyDataNormals() n.SetInputConnection(tg.GetOutputPort()) pdm = vtk.vtkPolyDataMapper() pdm.SetInputConnection(n.GetOutputPort())
def sphere(centers, colors, radii=1., theta=16, phi=16, vertices=None, faces=None): """Visualize one or many spheres with different colors and radii Parameters ---------- centers : ndarray, shape (N, 3) colors : ndarray (N,3) or (N, 4) or tuple (3,) or tuple (4,) RGB or RGBA (for opacity) R, G, B and A should be at the range [0, 1] radii : float or ndarray, shape (N,) theta : int phi : int vertices : ndarray, shape (N, 3) faces : ndarray, shape (M, 3) If faces is None then a sphere is created based on theta and phi angles If not then a sphere is created with the provided vertices and faces. Returns ------- vtkActor Examples -------- >>> from fury import window, actor >>> scene = window.Scene() >>> centers = np.random.rand(5, 3) >>> sphere_actor = actor.sphere(centers, window.colors.coral) >>> scene.add(sphere_actor) >>> # window.show(scene) """ if np.array(colors).ndim == 1: colors = np.tile(colors, (len(centers), 1)) if isinstance(radii, (float, int)): radii = radii * np.ones(len(centers), dtype='f8') pts = numpy_to_vtk_points(np.ascontiguousarray(centers)) cols = numpy_to_vtk_colors(255 * np.ascontiguousarray(colors)) cols.SetName('colors') radii_fa = numpy_support.numpy_to_vtk(np.ascontiguousarray( radii.astype('f8')), deep=0) radii_fa.SetName('rad') polydata_centers = vtk.vtkPolyData() polydata_sphere = vtk.vtkPolyData() if faces is None: src = vtk.vtkSphereSource() src.SetRadius(1) src.SetThetaResolution(theta) src.SetPhiResolution(phi) else: set_polydata_vertices(polydata_sphere, vertices) set_polydata_triangles(polydata_sphere, faces) polydata_centers.SetPoints(pts) polydata_centers.GetPointData().AddArray(radii_fa) polydata_centers.GetPointData().SetActiveScalars('rad') polydata_centers.GetPointData().AddArray(cols) glyph = vtk.vtkGlyph3D() if faces is None: glyph.SetSourceConnection(src.GetOutputPort()) else: glyph.SetSourceData(polydata_sphere) glyph.SetInputData(polydata_centers) glyph.Update() mapper = vtk.vtkPolyDataMapper() mapper.SetInputData(glyph.GetOutput()) mapper.SetScalarModeToUsePointFieldData() mapper.SelectColorArray('colors') actor = vtk.vtkActor() actor.SetMapper(mapper) return actor
#!/usr/bin/env python # This example demonstrates the use of vtkDepthSortPolyData. This is a # poor man's algorithm to sort polygons for proper transparent # blending. It sorts polygons based on a single point (i.e., # centroid) so the sorting may not work for overlapping or # intersection polygons. import vtk # Create a bunch of spheres that overlap and cannot be easily arranged # so that the blending works without sorting. They are appended into a # single vtkPolyData because the filter only sorts within a single # vtkPolyData input. sphere = vtk.vtkSphereSource() sphere.SetThetaResolution(80) sphere.SetPhiResolution(40) sphere.SetRadius(1) sphere.SetCenter(0, 0, 0) sphere2 = vtk.vtkSphereSource() sphere2.SetThetaResolution(80) sphere2.SetPhiResolution(40) sphere2.SetRadius(0.5) sphere2.SetCenter(1, 0, 0) sphere3 = vtk.vtkSphereSource() sphere3.SetThetaResolution(80) sphere3.SetPhiResolution(40) sphere3.SetRadius(0.5) sphere3.SetCenter(-1, 0, 0) sphere4 = vtk.vtkSphereSource() sphere4.SetThetaResolution(80)
def main(): rwi = vtk.vtkRenderWindowInteractor() istyle = vtk.vtkInteractorStyleImage() rwi.SetInteractorStyle(istyle) rw = vtk.vtkRenderWindow() rwi.SetRenderWindow(rw) ren = vtk.vtkRenderer() ren.SetBackground(1, 1, 1) ren.GetActiveCamera().SetParallelProjection(1) rw.AddRenderer(ren) rwi.Initialize() for i in range(-4, 3, 1): ta = vtk.vtkTextActor() ta.SetInput('%d: Hello World' % (i, )) ta.ScaledTextOn() x = 1.0 * i y = 2.0 * i ta.GetPositionCoordinate().SetCoordinateSystemToWorld() ta.GetPositionCoordinate().SetValue(x, y) # documentation claims that p2c is relative to pc, but in # VTK ParaView-3-2-1 that is not the case. x is relative, y # is just plain whacky. See below... # CASE A: # if we set y2 to 1.0 for example, everything with a y-coord # above 0 has the same y-position. Everything below 0 has # half the spacing it should have # see http://tinyurl.com/6jlr9e (vtktextactor_ybug_case_a.png) # CASE B: # if we try working around this by setting y2 to y+1.0 (i.e. # we DON'T assume that it's relative), everything with y >= 0 # is fine, everything below is at the right position, but # about half the height of everything with y above 0 # see http://tinyurl.com/6dfj47 (vtktextactor_ybug_case_b.png) # CASE A: #y2 = 1.0 # CASE B y2 = y + 1.0 x2 = x + 7 ta.GetPosition2Coordinate().SetCoordinateSystemToWorld() # this is a WORK-AROUND for the broken vtkTextActor position / # scaling in VTK ParaView-3-2-1 # only works if vtkTextActor justification mode is left at # default (I think that this has something to do with the fact # that the font scaling and the positioning interpret # position[2]coordinate differently. # more or less confirmed: setting justification to centered, # and y2 = y + 1.0, you can see that the positioning is # perfect, but if y < 0, the font size is at its absolute # minimum. if y < 0: # with y under 0, Position2Coordinate IS relative to # PositionCoordinate ta.GetPosition2Coordinate().SetValue(7, 1) else: # with y == 0 or above, Position2Coordinate's y-coordinate # has to specified absolutely ta.GetPosition2Coordinate().SetValue(7, y2) tprop = ta.GetTextProperty() tprop.SetFontFamilyToArial() #tprop.SetVerticalJustificationToCentered() #tprop.SetFontSize(12) tprop.SetBold(0) tprop.SetItalic(0) tprop.SetShadow(0) tprop.SetColor((0, 0, 0.4)) ############################ ren.AddActor(ta) # add a sphere source to calibrate # this should in theory be at the same position as the # vtkTextActor ss = vtk.vtkSphereSource() ss.SetRadius(0.1) sm = vtk.vtkPolyDataMapper() sm.SetInput(ss.GetOutput()) sa = vtk.vtkActor() sa.SetMapper(sm) sa.SetPosition((x, y, 0)) ren.AddActor(sa) # add a sphere source to calibrate # this should in theory be at the same position as the # vtkTextActor ss = vtk.vtkSphereSource() ss.SetRadius(0.1) sm = vtk.vtkPolyDataMapper() sm.SetInput(ss.GetOutput()) sa = vtk.vtkActor() sa.SetMapper(sm) sa.SetPosition((x2, y2, 0)) ren.AddActor(sa) ren.ResetCamera() rw.Render() rwi.Start()
def Execute(self): if not self.Network: self.Network = vtk.vtkPolyData() networkPoints = vtk.vtkPoints() networkLines = vtk.vtkCellArray() radiusArray = vtk.vtkDoubleArray() radiusArray.SetName(self.RadiusArrayName) self.Network.SetPoints(networkPoints) self.Network.SetLines(networkLines) self.Network.GetPointData().AddArray(radiusArray) if not self.vmtkRenderer: self.vmtkRenderer = vmtkrenderer.vmtkRenderer() self.vmtkRenderer.Initialize() self.OwnRenderer = 1 self.vmtkRenderer.ExitAfterTextInputMode = False self.vmtkRenderer.RegisterScript(self) if self.Image and (not self.PlaneWidgetX or not self.PlaneWidgetY or not self.PlaneWidgetZ): imageViewer = vmtkimageviewer.vmtkImageViewer() imageViewer.Image = self.Image imageViewer.vmtkRenderer = self.vmtkRenderer imageViewer.Display = 0 imageViewer.Execute() self.PlaneWidgetX = imageViewer.PlaneWidgetX self.PlaneWidgetY = imageViewer.PlaneWidgetY self.PlaneWidgetZ = imageViewer.PlaneWidgetZ if self.Image: spacing = self.Image.GetSpacing() self.CurrentRadius = min(spacing) if self.UseActiveTubes and not self.FeatureImage: imageFeatures = vmtkimagefeatures.vmtkImageFeatures() imageFeatures.Image = self.Image imageFeatures.FeatureImageType = 'vtkgradient' imageFeatures.Execute() self.FeatureImage = imageFeatures.FeatureImage self.NetworkRadiusArray = self.Network.GetPointData().GetArray( self.RadiusArrayName) self.Network.GetPointData().SetActiveScalars(self.RadiusArrayName) networkMapper = vtk.vtkPolyDataMapper() networkMapper.SetInputData(self.Network) networkMapper.SetScalarModeToUseCellData() self.NetworkActor = vtk.vtkActor() self.NetworkActor.SetMapper(networkMapper) self.vmtkRenderer.Renderer.AddActor(self.NetworkActor) self.NetworkTube = vtk.vtkTubeFilter() self.NetworkTube.SetInputData(self.Network) self.NetworkTube.SetVaryRadiusToVaryRadiusByAbsoluteScalar() self.NetworkTube.SetNumberOfSides(20) networkTubeMapper = vtk.vtkPolyDataMapper() networkTubeMapper.SetInputConnection(self.NetworkTube.GetOutputPort()) networkTubeMapper.ScalarVisibilityOff() networkTubeActor = vtk.vtkActor() networkTubeActor.SetMapper(networkTubeMapper) networkTubeActor.PickableOff() networkTubeActor.GetProperty().SetOpacity(0.2) self.vmtkRenderer.Renderer.AddActor(networkTubeActor) self.Selection = vtk.vtkPolyData() self.SelectionPoints = vtk.vtkPoints() self.SelectionRadiusArray = vtk.vtkDoubleArray() self.SelectionRadiusArray.SetName(self.RadiusArrayName) self.Selection.SetPoints(self.SelectionPoints) self.Selection.GetPointData().AddArray(self.SelectionRadiusArray) self.Selection.GetPointData().SetActiveScalars(self.RadiusArrayName) glyphs = vtk.vtkGlyph3D() glyphSource = vtk.vtkSphereSource() glyphSource.SetRadius(1.0) glyphSource.SetThetaResolution(20) glyphSource.SetPhiResolution(20) glyphs.SetInputData(self.Selection) glyphs.SetSourceConnection(glyphSource.GetOutputPort()) glyphs.SetScaleModeToScaleByScalar() glyphs.SetScaleFactor(1.0) selectionMapper = vtk.vtkPolyDataMapper() selectionMapper.SetInputConnection(glyphs.GetOutputPort()) self.SelectionActor = vtk.vtkActor() self.SelectionActor.SetMapper(selectionMapper) self.SelectionActor.GetProperty().SetColor(1.0, 0.0, 0.0) self.SelectionActor.GetProperty().SetOpacity(0.5) self.SelectionActor.PickableOff() self.vmtkRenderer.Renderer.AddActor(self.SelectionActor) self.ActiveSegmentSeeds = vtk.vtkPolyData() self.ActiveSegmentSeedsPoints = vtk.vtkPoints() self.ActiveSegmentSeedsRadiusArray = vtk.vtkDoubleArray() self.ActiveSegmentSeedsRadiusArray.SetName(self.RadiusArrayName) self.ActiveSegmentSeeds.SetPoints(self.ActiveSegmentSeedsPoints) self.ActiveSegmentSeeds.GetPointData().AddArray( self.ActiveSegmentSeedsRadiusArray) self.ActiveSegmentSeeds.GetPointData().SetActiveScalars( self.RadiusArrayName) activeSegmentSeedsGlyphs = vtk.vtkGlyph3D() activeSegmentSeedsGlyphSource = vtk.vtkSphereSource() activeSegmentSeedsGlyphSource.SetRadius(1.0) activeSegmentSeedsGlyphSource.SetThetaResolution(20) activeSegmentSeedsGlyphSource.SetPhiResolution(20) activeSegmentSeedsGlyphs.SetInputData(self.ActiveSegmentSeeds) activeSegmentSeedsGlyphs.SetSourceConnection( activeSegmentSeedsGlyphSource.GetOutputPort()) activeSegmentSeedsGlyphs.SetScaleModeToScaleByScalar() activeSegmentSeedsGlyphs.SetScaleFactor(1.0) activeSegmentSeedsMapper = vtk.vtkPolyDataMapper() activeSegmentSeedsMapper.SetInputConnection( activeSegmentSeedsGlyphs.GetOutputPort()) activeSegmentSeedsMapper.ScalarVisibilityOff() self.ActiveSegmentSeedsActor = vtk.vtkActor() self.ActiveSegmentSeedsActor.SetMapper(activeSegmentSeedsMapper) self.ActiveSegmentSeedsActor.GetProperty().SetColor(1.0, 0.0, 0.0) self.ActiveSegmentSeedsActor.GetProperty().SetOpacity(0.5) self.ActiveSegmentSeedsActor.PickableOff() self.vmtkRenderer.Renderer.AddActor(self.ActiveSegmentSeedsActor) self.ActiveSegment = vtk.vtkPolyData() self.ActiveSegmentPoints = vtk.vtkPoints() self.ActiveSegmentCellArray = vtk.vtkCellArray() self.ActiveSegmentRadiusArray = vtk.vtkDoubleArray() self.ActiveSegmentRadiusArray.SetName(self.RadiusArrayName) self.ActiveSegment.SetPoints(self.ActiveSegmentPoints) self.ActiveSegment.SetLines(self.ActiveSegmentCellArray) self.ActiveSegment.GetPointData().AddArray( self.ActiveSegmentRadiusArray) self.ActiveSegment.GetPointData().SetActiveScalars( self.RadiusArrayName) activeSegmentMapper = vtk.vtkPolyDataMapper() activeSegmentMapper.ScalarVisibilityOff() if self.SplineInterpolation and self.Image != None: splineFilter = vtk.vtkSplineFilter() splineFilter.SetInputData(self.ActiveSegment) splineFilter.SetSubdivideToLength() splineFilter.SetLength(2.0 * min(self.Image.GetSpacing())) activeSegmentMapper.SetInputConnection( splineFilter.GetOutputPort()) else: activeSegmentMapper.SetInputData(self.ActiveSegment) self.ActiveSegmentActor = vtk.vtkActor() self.ActiveSegmentActor.SetMapper(activeSegmentMapper) self.ActiveSegmentActor.GetProperty().SetColor(1.0, 1.0, 1.0) self.ActiveSegmentActor.GetProperty().SetLineWidth(3.0) self.ActiveSegmentActor.PickableOff() self.vmtkRenderer.Renderer.AddActor(self.ActiveSegmentActor) activeTube = vtk.vtkTubeFilter() activeTube.SetInputConnection(activeSegmentMapper.GetInputPort()) activeTube.SetVaryRadiusToVaryRadiusByAbsoluteScalar() activeTube.SetNumberOfSides(20) activeTubeMapper = vtk.vtkPolyDataMapper() activeTubeMapper.SetInputConnection(activeTube.GetOutputPort()) activeTubeMapper.ScalarVisibilityOff() activeTubeActor = vtk.vtkActor() activeTubeActor.SetMapper(activeTubeMapper) activeTubeActor.PickableOff() activeTubeActor.GetProperty().SetOpacity(0.6) self.vmtkRenderer.Renderer.AddActor(activeTubeActor) self.NetworkLabelsArray = vtk.vtkStringArray.SafeDownCast( self.Network.GetCellData().GetAbstractArray(self.LabelsArrayName)) if not self.NetworkLabelsArray: self.NetworkLabelsArray = vtk.vtkStringArray() self.NetworkLabelsArray.SetName(self.LabelsArrayName) self.NetworkLabelsArray.SetNumberOfValues( self.Network.GetNumberOfCells()) for i in range(self.Network.GetNumberOfCells()): self.NetworkLabelsArray.SetValue(i, '') self.Network.GetCellData().AddArray(self.NetworkLabelsArray) self.CellCenters = vtk.vtkCellCenters() self.CellCenters.SetInputData(self.Network) self.CellCenters.VertexCellsOff() self.CellCenters.Update() labeledMapper = vtk.vtkLabeledDataMapper() labeledMapper.SetInputConnection(self.CellCenters.GetOutputPort()) labeledMapper.SetLabelModeToLabelFieldData() labeledMapper.SetFieldDataName(self.LabelsArrayName) labeledMapper.GetLabelTextProperty().SetFontFamilyToArial() labeledMapper.GetLabelTextProperty().BoldOff() labeledMapper.GetLabelTextProperty().ItalicOff() labeledMapper.GetLabelTextProperty().ShadowOff() self.LabelsActor = vtk.vtkActor2D() self.LabelsActor.SetMapper(labeledMapper) self.LabelsActor.VisibilityOff() self.vmtkRenderer.Renderer.AddActor(self.LabelsActor) self.CellPicker = vtk.vtkCellPicker() self.CellPicker.SetTolerance(1E-2) self.CellPicker.InitializePickList() self.CellPicker.AddPickList(self.NetworkActor) self.CellPicker.PickFromListOn() self.vmtkRenderer.AddKeyBinding('a', 'Add mode.', self.AddCallback) self.vmtkRenderer.AddKeyBinding('d', 'Delete mode.', self.DeleteCallback) self.vmtkRenderer.AddKeyBinding('m', 'Merge mode.', self.MergeCallback) self.vmtkRenderer.AddKeyBinding('s', 'Split mode.', self.SplitCallback) self.vmtkRenderer.AddKeyBinding('l', 'Label mode.', self.LabelCallback) self.vmtkRenderer.AddKeyBinding('Tab', 'Show labels.', self.ShowLabelCallback) self.vmtkRenderer.RenderWindowInteractor.AddObserver( "KeyReleaseEvent", self.KeyReleaseCallback) self.vmtkRenderer.RenderWindowInteractor.AddObserver( "LeftButtonPressEvent", self.LeftButtonPressCallback) self.vmtkRenderer.RenderWindowInteractor.AddObserver( "MouseMoveEvent", self.MouseMoveCallback) if self.PlaneWidgetX: self.PlaneWidgetX.UseContinuousCursorOn() self.PlaneWidgetX.AddObserver("StartInteractionEvent", self.PlaneStartInteractionCallback) if self.PlaneWidgetY: self.PlaneWidgetY.UseContinuousCursorOn() self.PlaneWidgetY.AddObserver("StartInteractionEvent", self.PlaneStartInteractionCallback) if self.PlaneWidgetZ: self.PlaneWidgetZ.UseContinuousCursorOn() self.PlaneWidgetZ.AddObserver("StartInteractionEvent", self.PlaneStartInteractionCallback) self.FirstRender() self.Surface = self.NetworkTube.GetOutput() if self.OwnRenderer: self.vmtkRenderer.Deallocate()
from vtk.util.misc import vtkGetDataRoot VTK_DATA_ROOT = vtkGetDataRoot() ren1 = vtk.vtkRenderer() ren1.SetBackground(0, 0, 0) renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren1) renWin.SetSize(300, 300) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) pdb0 = vtk.vtkPDBReader() pdb0.SetFileName("" + str(VTK_DATA_ROOT) + "/Data/caffeine_notrailingspaces.pdb") pdb0.SetHBScale(1.0) pdb0.SetBScale(1.0) Sphere0 = vtk.vtkSphereSource() Sphere0.SetCenter(0, 0, 0) Sphere0.SetRadius(1) Sphere0.SetThetaResolution(8) Sphere0.SetStartTheta(0) Sphere0.SetEndTheta(360) Sphere0.SetPhiResolution(8) Sphere0.SetStartPhi(0) Sphere0.SetEndPhi(180) Glyph0 = vtk.vtkGlyph3D() Glyph0.SetInputConnection(pdb0.GetOutputPort()) Glyph0.SetOrient(1) Glyph0.SetColorMode(1) #Glyph0 ScalingOn Glyph0.SetScaleMode(2) Glyph0.SetScaleFactor(.25)
def __init__(self, node, textHeight=5): # Get the node's position X = node.X # Global X coordinate Y = node.Y # Global Y coordinate Z = node.Z # Global Z coordinate # Generate a sphere for the node sphere = vtk.vtkSphereSource() sphere.SetCenter(X, Y, Z) sphere.SetRadius(0.6 * textHeight) # Set up a mapper for the node mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(sphere.GetOutputPort()) # Set up an actor for the node self.actor = vtk.vtkActor() self.actor.SetMapper(mapper) # Create the text for the node label label = vtk.vtkVectorText() label.SetText(node.Name) # Set up a mapper for the node label lblMapper = vtk.vtkPolyDataMapper() lblMapper.SetInputConnection(label.GetOutputPort()) # Set up an actor for the node label self.lblActor = vtk.vtkFollower() self.lblActor.SetMapper(lblMapper) self.lblActor.SetScale(textHeight, textHeight, textHeight) self.lblActor.SetPosition(X + 0.6 * textHeight, Y + 0.6 * textHeight, Z) # Generate any supports that occur at the node supportMappers = [] self.supportActors = [] # Check for a fixed suppport if (node.SupportDX == True) and (node.SupportDY == True) and (node.SupportDZ == True) \ and (node.SupportRX == True) and (node.SupportRY == True) and (node.SupportRZ == True): # Create the fixed support support = vtk.vtkCubeSource() support.SetCenter(node.X, node.Y, node.Z) support.SetXLength(textHeight * 1.2) support.SetYLength(textHeight * 1.2) support.SetZLength(textHeight * 1.2) # Change the node's mapper to the fixed support mapper.SetInputConnection(support.GetOutputPort()) # Check for a pinned support elif (node.SupportDX == True) and (node.SupportDY == True) and (node.SupportDZ == True) \ and (node.SupportRX == False) and (node.SupportRY == False) and (node.SupportRZ == False): # Create the pinned support support = vtk.vtkConeSource() support.SetCenter(node.X, node.Y - 0.6 * textHeight, node.Z) support.SetDirection((0, 1, 0)) support.SetHeight(textHeight * 1.2) support.SetRadius(textHeight * 1.2) # Change the node's mapper to the pinned support mapper.SetInputConnection(support.GetOutputPort()) # Other support conditions else: # Restrained against X translation if (node.SupportDX == True): # Create the support support1 = vtk.vtkLineSource( ) # The line showing the support direction support1.SetPoint1(node.X - textHeight, node.Y, node.Z) support1.SetPoint2(node.X + textHeight, node.Y, node.Z) support2 = vtk.vtkConeSource() support2.SetCenter(node.X - textHeight, node.Y, node.Z) support2.SetDirection((1, 0, 0)) support2.SetHeight(textHeight * 0.6) support2.SetRadius(textHeight * 0.3) support3 = vtk.vtkConeSource() support3.SetCenter(node.X + textHeight, node.Y, node.Z) support3.SetDirection((-1, 0, 0)) support3.SetHeight(textHeight * 0.6) support3.SetRadius(textHeight * 0.3) # Set up mappers for the support supportMapper1 = vtk.vtkPolyDataMapper() supportMapper2 = vtk.vtkPolyDataMapper() supportMapper3 = vtk.vtkPolyDataMapper() supportMapper1.SetInputConnection(support1.GetOutputPort()) supportMapper2.SetInputConnection(support2.GetOutputPort()) supportMapper3.SetInputConnection(support3.GetOutputPort()) supportMappers.append(supportMapper1) supportMappers.append(supportMapper2) supportMappers.append(supportMapper3) # Set up actors for the support supportActor1 = vtk.vtkActor() supportActor2 = vtk.vtkActor() supportActor3 = vtk.vtkActor() supportActor1.SetMapper(supportMapper1) supportActor2.SetMapper(supportMapper2) supportActor3.SetMapper(supportMapper3) self.supportActors.append(supportActor1) self.supportActors.append(supportActor2) self.supportActors.append(supportActor3) # Restrained against Y translation if (node.SupportDY == True): # Create the support support1 = vtk.vtkLineSource( ) # The line showing the support direction support1.SetPoint1(node.X, node.Y - textHeight, node.Z) support1.SetPoint2(node.X, node.Y + textHeight, node.Z) support2 = vtk.vtkConeSource() support2.SetCenter(node.X, node.Y - textHeight, node.Z) support2.SetDirection((0, 1, 0)) support2.SetHeight(textHeight * 0.6) support2.SetRadius(textHeight * 0.3) support3 = vtk.vtkConeSource() support3.SetCenter(node.X, node.Y + textHeight, node.Z) support3.SetDirection((0, -1, 0)) support3.SetHeight(textHeight * 0.6) support3.SetRadius(textHeight * 0.3) # Set up mappers for the support supportMapper1 = vtk.vtkPolyDataMapper() supportMapper2 = vtk.vtkPolyDataMapper() supportMapper3 = vtk.vtkPolyDataMapper() supportMapper1.SetInputConnection(support1.GetOutputPort()) supportMapper2.SetInputConnection(support2.GetOutputPort()) supportMapper3.SetInputConnection(support3.GetOutputPort()) supportMappers.append(supportMapper1) supportMappers.append(supportMapper2) supportMappers.append(supportMapper3) # Set up actors for the support supportActor1 = vtk.vtkActor() supportActor2 = vtk.vtkActor() supportActor3 = vtk.vtkActor() supportActor1.SetMapper(supportMapper1) supportActor2.SetMapper(supportMapper2) supportActor3.SetMapper(supportMapper3) self.supportActors.append(supportActor1) self.supportActors.append(supportActor2) self.supportActors.append(supportActor3) # Restrained against Z translation if (node.SupportDZ == True): # Create the support support1 = vtk.vtkLineSource( ) # The line showing the support direction support1.SetPoint1(node.X, node.Y, node.Z - textHeight) support1.SetPoint2(node.X, node.Y, node.Z + textHeight) support2 = vtk.vtkConeSource() support2.SetCenter(node.X, node.Y, node.Z - textHeight) support2.SetDirection((0, 0, 1)) support2.SetHeight(textHeight * 0.6) support2.SetRadius(textHeight * 0.3) support3 = vtk.vtkConeSource() support3.SetCenter(node.X, node.Y, node.Z + textHeight) support3.SetDirection((0, 0, -1)) support3.SetHeight(textHeight * 0.6) support3.SetRadius(textHeight * 0.3) # Set up mappers for the support supportMapper1 = vtk.vtkPolyDataMapper() supportMapper2 = vtk.vtkPolyDataMapper() supportMapper3 = vtk.vtkPolyDataMapper() supportMapper1.SetInputConnection(support1.GetOutputPort()) supportMapper2.SetInputConnection(support2.GetOutputPort()) supportMapper3.SetInputConnection(support3.GetOutputPort()) supportMappers.append(supportMapper1) supportMappers.append(supportMapper2) supportMappers.append(supportMapper3) # Set actors for the support supportActor1 = vtk.vtkActor() supportActor2 = vtk.vtkActor() supportActor3 = vtk.vtkActor() supportActor1.SetMapper(supportMapper1) supportActor2.SetMapper(supportMapper2) supportActor3.SetMapper(supportMapper3) self.supportActors.append(supportActor1) self.supportActors.append(supportActor2) self.supportActors.append(supportActor3) # Restrained against rotation about the X-axis if (node.SupportRX == True): # Create the support support1 = vtk.vtkLineSource( ) # The line showing the support direction support1.SetPoint1(node.X - 1.6 * textHeight, node.Y, node.Z) support1.SetPoint2(node.X + 1.6 * textHeight, node.Y, node.Z) support2 = vtk.vtkCubeSource() support2.SetCenter(node.X - 1.9 * textHeight, node.Y, node.Z) support2.SetXLength(textHeight * 0.6) support2.SetYLength(textHeight * 0.6) support2.SetZLength(textHeight * 0.6) support3 = vtk.vtkCubeSource() support3.SetCenter(node.X + 1.9 * textHeight, node.Y, node.Z) support3.SetXLength(textHeight * 0.6) support3.SetYLength(textHeight * 0.6) support3.SetZLength(textHeight * 0.6) # Set up mappers for the support supportMapper1 = vtk.vtkPolyDataMapper() supportMapper2 = vtk.vtkPolyDataMapper() supportMapper3 = vtk.vtkPolyDataMapper() supportMapper1.SetInputConnection(support1.GetOutputPort()) supportMapper2.SetInputConnection(support2.GetOutputPort()) supportMapper3.SetInputConnection(support3.GetOutputPort()) supportMappers.append(supportMapper1) supportMappers.append(supportMapper2) supportMappers.append(supportMapper3) # Set up actors for the support supportActor1 = vtk.vtkActor() supportActor2 = vtk.vtkActor() supportActor3 = vtk.vtkActor() supportActor1.SetMapper(supportMapper1) supportActor2.SetMapper(supportMapper2) supportActor3.SetMapper(supportMapper3) self.supportActors.append(supportActor1) self.supportActors.append(supportActor2) self.supportActors.append(supportActor3) # Restrained against rotation about the Y-axis if (node.SupportRY == True): # Create the support support1 = vtk.vtkLineSource( ) # The line showing the support direction support1.SetPoint1(node.X, node.Y - 1.6 * textHeight, node.Z) support1.SetPoint2(node.X, node.Y + 1.6 * textHeight, node.Z) support2 = vtk.vtkCubeSource() support2.SetCenter(node.X, node.Y - 1.9 * textHeight, node.Z) support2.SetXLength(textHeight * 0.6) support2.SetYLength(textHeight * 0.6) support2.SetZLength(textHeight * 0.6) support3 = vtk.vtkCubeSource() support3.SetCenter(node.X, node.Y + 1.9 * textHeight, node.Z) support3.SetXLength(textHeight * 0.6) support3.SetYLength(textHeight * 0.6) support3.SetZLength(textHeight * 0.6) # Set up mappers for the support supportMapper1 = vtk.vtkPolyDataMapper() supportMapper2 = vtk.vtkPolyDataMapper() supportMapper3 = vtk.vtkPolyDataMapper() supportMapper1.SetInputConnection(support1.GetOutputPort()) supportMapper2.SetInputConnection(support2.GetOutputPort()) supportMapper3.SetInputConnection(support3.GetOutputPort()) supportMappers.append(supportMapper1) supportMappers.append(supportMapper2) supportMappers.append(supportMapper3) # Set up actors for the support supportActor1 = vtk.vtkActor() supportActor2 = vtk.vtkActor() supportActor3 = vtk.vtkActor() supportActor1.SetMapper(supportMapper1) supportActor2.SetMapper(supportMapper2) supportActor3.SetMapper(supportMapper3) self.supportActors.append(supportActor1) self.supportActors.append(supportActor2) self.supportActors.append(supportActor3) # Restrained against rotation about the Z-axis if (node.SupportRZ == True): # Create the support support1 = vtk.vtkLineSource( ) # The line showing the support direction support1.SetPoint1(node.X, node.Y, node.Z - 1.6 * textHeight) support1.SetPoint2(node.X, node.Y, node.Z + 1.6 * textHeight) support2 = vtk.vtkCubeSource() support2.SetCenter(node.X, node.Y, node.Z - 1.9 * textHeight) support2.SetXLength(textHeight * 0.6) support2.SetYLength(textHeight * 0.6) support2.SetZLength(textHeight * 0.6) support3 = vtk.vtkCubeSource() support3.SetCenter(node.X, node.Y, node.Z + 1.9 * textHeight) support3.SetXLength(textHeight * 0.6) support3.SetYLength(textHeight * 0.6) support3.SetZLength(textHeight * 0.6) # Set up mappers for the support supportMapper1 = vtk.vtkPolyDataMapper() supportMapper2 = vtk.vtkPolyDataMapper() supportMapper3 = vtk.vtkPolyDataMapper() supportMapper1.SetInputConnection(support1.GetOutputPort()) supportMapper2.SetInputConnection(support2.GetOutputPort()) supportMapper3.SetInputConnection(support3.GetOutputPort()) supportMappers.append(supportMapper1) supportMappers.append(supportMapper2) supportMappers.append(supportMapper3) # Set up actors for the support supportActor1 = vtk.vtkActor() supportActor2 = vtk.vtkActor() supportActor3 = vtk.vtkActor() supportActor1.SetMapper(supportMapper1) supportActor2.SetMapper(supportMapper2) supportActor3.SetMapper(supportMapper3) self.supportActors.append(supportActor1) self.supportActors.append(supportActor2) self.supportActors.append(supportActor3)
def Execute(self): if self.Surface == None: self.PrintError('Error: No input surface.') if not self.vmtkRenderer: self.vmtkRenderer = vmtkrenderer.vmtkRenderer() self.vmtkRenderer.Initialize() self.OwnRenderer = 1 self.vmtkRenderer.RegisterScript(self) glyphs = vtk.vtkGlyph3D() glyphSource = vtk.vtkSphereSource() glyphSource.SetRadius(1) glyphs.SetInputData(self.Spheres) glyphs.SetSourceConnection(glyphSource.GetOutputPort()) glyphs.SetScaleModeToScaleByScalar() glyphs.SetScaleFactor(1.) glyphMapper = vtk.vtkPolyDataMapper() glyphMapper.SetInputConnection(glyphs.GetOutputPort()) glyphMapper.ScalarVisibilityOff() self.SpheresActor = vtk.vtkActor() self.SpheresActor.SetMapper(glyphMapper) self.SpheresActor.GetProperty().SetColor(1.0, 0.0, 0.0) self.SpheresActor.GetProperty().SetOpacity(self.Opacity) self.SpheresActor.PickableOff() self.vmtkRenderer.Renderer.AddActor(self.SpheresActor) examineGlyphs = vtk.vtkGlyph3D() examineGlyphSource = vtk.vtkSphereSource() examineGlyphSource.SetRadius(1) examineGlyphs.SetInputData(self.ExamineSpheres) examineGlyphs.SetSourceConnection(examineGlyphSource.GetOutputPort()) examineGlyphs.SetScaleModeToScaleByScalar() examineGlyphs.SetScaleFactor(1.) examineGlyphMapper = vtk.vtkPolyDataMapper() examineGlyphMapper.SetInputConnection(examineGlyphs.GetOutputPort()) examineGlyphMapper.ScalarVisibilityOff() self.ExamineSpheresActor = vtk.vtkActor() self.ExamineSpheresActor.SetMapper(examineGlyphMapper) self.ExamineSpheresActor.GetProperty().SetColor(0.0, 1.0, 0.0) self.ExamineSpheresActor.GetProperty().SetOpacity(self.Opacity) self.ExamineSpheresActor.PickableOff() self.ExamineSpheresActor.VisibilityOff() self.vmtkRenderer.Renderer.AddActor(self.ExamineSpheresActor) #self.vmtkRenderer.RenderWindowInteractor.AddObserver("KeyPressEvent", self.KeyPressed) self.vmtkRenderer.AddKeyBinding('u', 'undo', self.UndoCallback) self.vmtkRenderer.AddKeyBinding('plus', 'Increase sphere radius', self.PlusCallback) self.vmtkRenderer.AddKeyBinding('minus', 'Decrease sphere radius', self.MinusCallback) self.vmtkRenderer.AddKeyBinding('n', 'Show next sphere', self.NextSphereCallback) self.vmtkRenderer.AddKeyBinding('v', 'Show previous sphere', self.PreviousSphereCallback) self.vmtkRenderer.AddKeyBinding('d', 'Display ', self.DisplayCallback) self.vmtkRenderer.AddKeyBinding( 'w', 'Switch beetween examien and interact mode ', self.ExmienModeCallback) self.vmtkRenderer.AddKeyBinding('space', 'Pick sphere', self.PickCallback) self.SurfaceMapper = vtk.vtkPolyDataMapper() self.SurfaceMapper.SetInputData(self.Surface) self.SurfaceMapper.SetScalarVisibility(self.DisplayArray) surfaceActor = vtk.vtkActor() surfaceActor.SetMapper(self.SurfaceMapper) surfaceActor.GetProperty().SetOpacity(self.Opacity) self.vmtkRenderer.Renderer.AddActor(surfaceActor) self.ScalarBarActor = vtk.vtkScalarBarActor() self.ScalarBarActor.SetLookupTable(self.SurfaceMapper.GetLookupTable()) self.ScalarBarActor.GetLabelTextProperty().ItalicOff() self.ScalarBarActor.GetLabelTextProperty().BoldOff() self.ScalarBarActor.GetLabelTextProperty().ShadowOff() self.ScalarBarActor.SetLabelFormat('%.2f') self.ScalarBarActor.SetTitle('distances') self.ScalarBarActor.VisibilityOff() self.vmtkRenderer.Renderer.AddActor(self.ScalarBarActor) self.SphereWidget = vtk.vtkSphereWidget() self.SphereWidget.TranslationOff() self.SphereWidget.SetInteractor( self.vmtkRenderer.RenderWindowInteractor) self.SphereWidget.AddObserver("InteractionEvent", self.SphereCallback) self.ExamineText = vtk.vtkTextActor() self.ExamineText.SetInput("Examine Mode") self.ExamineText.GetPositionCoordinate( ).SetCoordinateSystemToNormalizedViewport() self.ExamineText.SetPosition(0.05, 0.95) self.ExamineText.VisibilityOff() self.vmtkRenderer.Renderer.AddActor2D(self.ExamineText) self.InputInfo( 'Please position the mouse and press space to add spheres, \'u\' to undo\n' ) any = 0 while any == 0: self.InitializeSpheres() self.vmtkRenderer.Render() any = (self.Spheres.GetNumberOfPoints() > 1) self.Surface = self.ComputeArray() if self.OwnRenderer: self.vmtkRenderer.Deallocate()
image_actor_z.opacity(slicer_opacity) image_actor_x = image_actor_z.copy() x_midpoint = int(np.round(shape[0] / 2)) image_actor_x.display_extent(x_midpoint, x_midpoint, 0, shape[1] - 1, 0, shape[2] - 1) image_actor_y = image_actor_z.copy() y_midpoint = int(np.round(shape[1] / 2)) image_actor_y.display_extent(0, shape[0] - 1, y_midpoint, y_midpoint, 0, shape[2] - 1) # ---create sphere--- z_midpoint = int(np.round(shape[2] / 2)) init_pos = affine.dot([x_midpoint, y_midpoint, z_midpoint, 1]) sphere_src = vtk.vtkSphereSource() sphere_src.SetCenter( 0, 0, 0) # the origin of the coordinate system, not the position of the sphere sphere_src.SetRadius(5.0) sphere_mapper = vtk.vtkPolyDataMapper() sphere_mapper.SetInputConnection(sphere_src.GetOutputPort()) sphere_actor = vtk.vtkActor() sphere_actor.SetMapper(sphere_mapper) sphere_actor.SetPosition(init_pos[0], init_pos[1], init_pos[2]) # position is relative to the center ren.add(image_actor_x) ren.add(image_actor_y) ren.add(image_actor_z) ren.add(sphere_actor)
def test_MaskVolume1(self): """ Basic automated test of the segmentation method: - Create segmentation by placing sphere-shaped seeds - Run segmentation - Verify results using segment statistics The test can be executed from SelfTests module (test name: SegmentEditorMaskVolume) """ self.delayDisplay("Starting test_MaskVolume1") import vtkSegmentationCorePython as vtkSegmentationCore import vtkSlicerSegmentationsModuleLogicPython as vtkSlicerSegmentationsModuleLogic import SampleData from SegmentStatistics import SegmentStatisticsLogic ################################## self.delayDisplay("Load master volume") import SampleData sampleDataLogic = SampleData.SampleDataLogic() masterVolumeNode = sampleDataLogic.downloadMRBrainTumor1() ################################## self.delayDisplay("Create segmentation containing a few spheres") segmentationNode = slicer.vtkMRMLSegmentationNode() slicer.mrmlScene.AddNode(segmentationNode) segmentationNode.CreateDefaultDisplayNodes() segmentationNode.SetReferenceImageGeometryParameterFromVolumeNode( masterVolumeNode) # Segments are defined by a list of: name and a list of sphere [radius, posX, posY, posZ] segmentGeometries = [['Tumor', [[10, -6, 30, 28]]], [ 'Background', [[10, 0, 65, 22], [15, 1, -14, 30], [12, 0, 28, -7], [5, 0, 30, 54], [12, 31, 33, 27], [17, -42, 30, 27], [6, -2, -17, 71]] ], ['Air', [[10, 76, 73, 0], [15, -70, 74, 0]]]] for segmentGeometry in segmentGeometries: segmentName = segmentGeometry[0] appender = vtk.vtkAppendPolyData() for sphere in segmentGeometry[1]: sphereSource = vtk.vtkSphereSource() sphereSource.SetRadius(sphere[0]) sphereSource.SetCenter(sphere[1], sphere[2], sphere[3]) appender.AddInputConnection(sphereSource.GetOutputPort()) segment = vtkSegmentationCore.vtkSegment() segment.SetName( segmentationNode.GetSegmentation().GenerateUniqueSegmentID( segmentName)) appender.Update() segment.AddRepresentation( vtkSegmentationCore.vtkSegmentationConverter. GetSegmentationClosedSurfaceRepresentationName(), appender.GetOutput()) segmentationNode.GetSegmentation().AddSegment(segment) ################################## self.delayDisplay("Create segment editor") segmentEditorWidget = slicer.qMRMLSegmentEditorWidget() segmentEditorWidget.show() segmentEditorWidget.setMRMLScene(slicer.mrmlScene) segmentEditorNode = slicer.vtkMRMLSegmentEditorNode() slicer.mrmlScene.AddNode(segmentEditorNode) segmentEditorWidget.setMRMLSegmentEditorNode(segmentEditorNode) segmentEditorWidget.setSegmentationNode(segmentationNode) segmentEditorWidget.setMasterVolumeNode(masterVolumeNode) ################################## self.delayDisplay("Run segmentation") segmentEditorWidget.setActiveEffectByName("MaskVolume") effect = segmentEditorWidget.activeEffect() effect.setParameter("ObjectScaleMm", 3.0) effect.self().onApply() ################################## self.delayDisplay("Make segmentation results nicely visible in 3D") segmentationDisplayNode = segmentationNode.GetDisplayNode() segmentationDisplayNode.SetSegmentVisibility("Air", False) segmentationDisplayNode.SetSegmentOpacity3D("Background", 0.5) ################################## self.delayDisplay("Compute statistics") segStatLogic = SegmentStatisticsLogic() segStatLogic.computeStatistics(segmentationNode, masterVolumeNode) # Export results to table (just to see all results) resultsTableNode = slicer.vtkMRMLTableNode() slicer.mrmlScene.AddNode(resultsTableNode) segStatLogic.exportToTable(resultsTableNode) segStatLogic.showTable(resultsTableNode) self.delayDisplay("Check a few numerical results") self.assertEqual( round(segStatLogic.statistics["Tumor", "LM volume cc"]), 16) self.assertEqual( round(segStatLogic.statistics["Background", "LM volume cc"]), 3010) self.delayDisplay('test_MaskVolume1 passed')
def __init__(self, path, fiducialListNode, outputPathNode=None, cursorType=None): """ :param path: path points as numpy array. :param fiducialListNode: input node, just used for naming the output node. :param outputPathNode: output model node that stores the path points. :param cursorType: can be 'markups' or 'model'. Markups has a number of advantages (radius it is easier to change the size, can jump to views by clicking on it, has more visualization options, can be scaled to fixed display size), but if some applications relied on having a model node as cursor then this argument can be used to achieve that. """ fids = fiducialListNode scene = slicer.mrmlScene self.cursorType = "markups" if cursorType is None else cursorType points = vtk.vtkPoints() polyData = vtk.vtkPolyData() polyData.SetPoints(points) lines = vtk.vtkCellArray() polyData.SetLines(lines) linesIDArray = lines.GetData() linesIDArray.Reset() linesIDArray.InsertNextTuple1(0) polygons = vtk.vtkCellArray() polyData.SetPolys(polygons) idArray = polygons.GetData() idArray.Reset() idArray.InsertNextTuple1(0) for point in path: pointIndex = points.InsertNextPoint(*point) linesIDArray.InsertNextTuple1(pointIndex) linesIDArray.SetTuple1(0, linesIDArray.GetNumberOfTuples() - 1) lines.SetNumberOfCells(1) import vtk.util.numpy_support as VN pointsArray = VN.vtk_to_numpy(points.GetData()) self.planePosition, self.planeNormal = self.planeFit(pointsArray.T) # Create model node model = outputPathNode if not model: model = scene.AddNewNodeByClass( "vtkMRMLModelNode", scene.GenerateUniqueName("Path-%s" % fids.GetName())) model.CreateDefaultDisplayNodes() model.GetDisplayNode().SetColor(1, 1, 0) # yellow model.SetAndObservePolyData(polyData) # Camera cursor cursor = model.GetNodeReference("CameraCursor") if not cursor: if self.cursorType == "markups": # Markups cursor cursor = scene.AddNewNodeByClass( "vtkMRMLMarkupsFiducialNode", scene.GenerateUniqueName("Cursor-%s" % fids.GetName())) cursor.CreateDefaultDisplayNodes() cursor.GetDisplayNode().SetSelectedColor(1, 0, 0) # red cursor.GetDisplayNode().SetSliceProjection(True) cursor.AddControlPoint(vtk.vtkVector3d(0, 0, 0), " ") # do not show any visible label cursor.SetNthControlPointLocked(0, True) else: # Model cursor cursor = scene.AddNewNodeByClass( "vtkMRMLMarkupsModelNode", scene.GenerateUniqueName("Cursor-%s" % fids.GetName())) cursor.CreateDefaultDisplayNodes() cursor.GetDisplayNode().SetColor(1, 0, 0) # red cursor.GetDisplayNode().BackfaceCullingOn( ) # so that the camera can see through the cursor from inside # Add a sphere as cursor sphere = vtk.vtkSphereSource() sphere.Update() cursor.SetPolyDataConnection(sphere.GetOutputPort()) model.SetNodeReferenceID("CameraCursor", cursor.GetID()) # Transform node transform = model.GetNodeReference("CameraTransform") if not transform: transform = scene.AddNewNodeByClass( "vtkMRMLLinearTransformNode", scene.GenerateUniqueName("Transform-%s" % fids.GetName())) model.SetNodeReferenceID("CameraTransform", transform.GetID()) cursor.SetAndObserveTransformNodeID(transform.GetID()) self.transform = transform