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
