def __init__(self, parent=None):
super(VTKFrame, self).__init__(parent)
self.vtkWidget = QVTKRenderWindowInteractor(self)
vl = QtGui.QVBoxLayout(self)
vl.addWidget(self.vtkWidget)
vl.setContentsMargins(0, 0, 0, 0)
self.ren = vtk.vtkRenderer()
self.vtkWidget.GetRenderWindow().AddRenderer(self.ren)
self.iren = self.vtkWidget.GetRenderWindow().GetInteractor()
superquadricSource = vtk.vtkSuperquadricSource()
superquadricSource.SetPhiRoundness(3.1)
superquadricSource.SetThetaRoundness(2.2)
clipPlane = vtk.vtkPlane()
clipPlane.SetNormal(1.0, -1.0, -1.0)
clipPlane.SetOrigin(0, 0, 0)
clipper = vtk.vtkClipPolyData()
clipper.SetInputConnection(superquadricSource.GetOutputPort())
clipper.SetClipFunction(clipPlane)
superquadricMapper = vtk.vtkPolyDataMapper()
superquadricMapper.SetInputConnection(clipper.GetOutputPort())
superquadricActor = vtk.vtkActor()
superquadricActor.SetMapper(superquadricMapper)
#create renderers and add actors of plane and cube
self.ren.AddActor(superquadricActor)
self.ren.ResetCamera()
self._initialized = False
def __init__(self, module_manager):
SimpleVTKClassModuleBase.__init__(
self, module_manager,
vtk.vtkSuperquadricSource(), 'Processing.',
(), ('vtkPolyData',),
replaceDoc=True,
inputFunctions=None, outputFunctions=None)
def MakeTorus():
'''
Make a torus as the source.
:return: vtkPolyData with normal and scalar data.
'''
source = vtk.vtkSuperquadricSource();
source.SetCenter(0.0, 0.0, 0.0)
source.SetScale(1.0, 1.0, 1.0)
source.SetPhiResolution(64)
source.SetThetaResolution(64)
source.SetThetaRoundness(1)
source.SetThickness(0.5)
source.SetSize(10)
source.SetToroidal(1)
# The quadric is made of strips, so pass it through a triangle filter as
# the curvature filter only operates on polys
tri = vtk.vtkTriangleFilter()
tri.SetInputConnection(source.GetOutputPort())
# The quadric has nasty discontinuities from the way the edges are generated
# so let's pass it though a CleanPolyDataFilter and merge any points which
# are coincident, or very close
cleaner = vtk.vtkCleanPolyData()
cleaner.SetInputConnection(tri.GetOutputPort())
cleaner.SetTolerance(0.005)
cleaner.Update()
return CalculateCurvatures(MakeElevations(cleaner.GetOutput()))
def SuperquadricSource():
"""
Make a torus as the source.
"""
source = vtk.vtkSuperquadricSource()
source.SetCenter(0.0, 0.0, 0.0)
source.SetScale(1.0, 1.0, 1.0)
source.SetPhiResolution(64)
source.SetThetaResolution(64)
source.SetThetaRoundness(1)
source.SetThickness(0.5)
source.SetSize(10)
source.SetToroidal(1)
# The quadric is made of strips, so pass it through a triangle filter as
# the curvature filter only operates on polys
tri = vtk.vtkTriangleFilter()
tri.SetInputConnection(source.GetOutputPort())
# The quadric has nasty discontinuities from the way the edges are generated
# so let's pass it though a CleanPolyDataFilter and merge any points which
# are coincident, or very close
cleaner = vtk.vtkCleanPolyData()
cleaner.SetInputConnection(tri.GetOutputPort())
cleaner.SetTolerance(0.005)
cleaner.Update()
cleanerBounds = cleaner.GetOutput().GetBounds()
elev = vtk.vtkElevationFilter()
elev.SetInputConnection(cleaner.GetOutputPort())
elev.SetLowPoint(0, cleanerBounds[2], 0)
elev.SetHighPoint(0, cleanerBounds[3], 0)
elev.Update()
return elev
def add_superquadric(self):
"""Add a new superquadric at a random position.
This is called by the event handler for the 'Add Superquadric'
button.
"""
import random
# let's add a superquadric actor to the renderer
sqs = vtk.vtkSuperquadricSource()
sqs.ToroidalOn()
sqs.SetSize(0.1) # default is 0.5
m = vtk.vtkPolyDataMapper()
m.SetInput(sqs.GetOutput())
a = vtk.vtkActor()
a.SetMapper(m)
pos = [random.random() for _ in range(3)]
a.SetPosition(pos)
a.GetProperty().SetColor([random.random() for _ in range(3)])
self.ren.AddActor(a)
self.render()
# add string to files listcontrol showing where the
# superquadric was placed.
self._view_frame.files_lc.InsertStringItem(
sys.maxint, 'Position (%.2f, %.2f, %.2f)' % tuple(pos))
def MakeTorus():
"""
Make a torus as the source.
:return: vtkPolyData with normal and scalar data.
"""
source = vtk.vtkSuperquadricSource()
source.SetCenter(0.0, 0.0, 0.0)
source.SetScale(1.0, 1.0, 1.0)
source.SetPhiResolution(64)
source.SetThetaResolution(64)
source.SetThetaRoundness(1)
source.SetThickness(0.5)
source.SetSize(10)
source.SetToroidal(1)
# The quadric is made of strips, so pass it through a triangle filter as
# the curvature filter only operates on polys
tri = vtk.vtkTriangleFilter()
tri.SetInputConnection(source.GetOutputPort())
# The quadric has nasty discontinuities from the way the edges are generated
# so let's pass it though a CleanPolyDataFilter and merge any points which
# are coincident, or very close
cleaner = vtk.vtkCleanPolyData()
cleaner.SetInputConnection(tri.GetOutputPort())
cleaner.SetTolerance(0.005)
cleaner.Update()
return CalculateCurvatures(MakeElevations(cleaner.GetOutput()))
def add_superquadric(self):
"""Add a new superquadric at a random position.
This is called by the event handler for the 'Add Superquadric'
button.
"""
import random
# let's add a superquadric actor to the renderer
sqs = vtk.vtkSuperquadricSource()
sqs.ToroidalOn()
sqs.SetSize(0.1) # default is 0.5
m = vtk.vtkPolyDataMapper()
m.SetInput(sqs.GetOutput())
a = vtk.vtkActor()
a.SetMapper(m)
pos = [random.random() for _ in range(3)]
a.SetPosition(pos)
a.GetProperty().SetColor([random.random() for _ in range(3)])
self.ren.AddActor(a)
self.render()
# add string to files listcontrol showing where the
# superquadric was placed.
self._view_frame.files_lc.InsertStringItem(
sys.maxint, 'Position (%.2f, %.2f, %.2f)' % tuple(pos))
def main():
res = 6
plane = vtk.vtkPlaneSource()
plane.SetResolution(res, res)
colors = vtk.vtkElevationFilter()
colors.SetInputConnection(plane.GetOutputPort())
colors.SetLowPoint(-0.25, -0.25, -0.25)
colors.SetHighPoint(0.25, 0.25, 0.25)
planeMapper = vtk.vtkPolyDataMapper()
planeMapper.SetInputData(colors.GetPolyDataOutput())
planeActor = vtk.vtkActor()
planeActor.SetMapper(planeMapper)
planeActor.GetProperty().SetRepresentationToWireframe()
# create simple poly data so we can apply glyph
squad = vtk.vtkSuperquadricSource()
def Glyph():
"""
# procedure for generating glyphs
:return:
"""
xyz = glypher.GetPoint()
x = xyz[0]
y = xyz[1]
length = glypher.GetInput(0).GetLength()
scale = length / (2.0 * res)
squad.SetScale(scale, scale, scale)
squad.SetCenter(xyz)
squad.SetPhiRoundness(abs(x) * 5.0)
squad.SetThetaRoundness(abs(y) * 5.0)
glypher = vtk.vtkProgrammableGlyphFilter()
glypher.SetInputConnection(colors.GetOutputPort())
glypher.SetSourceConnection(squad.GetOutputPort())
glypher.SetGlyphMethod(Glyph)
glyphMapper = vtk.vtkPolyDataMapper()
glyphMapper.SetInputConnection(glypher.GetOutputPort())
glyphActor = vtk.vtkActor()
glyphActor.SetMapper(glyphMapper)
colors = vtk.vtkNamedColors()
# Create the rendering stuff
ren1 = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.SetMultiSamples(0)
renWin.AddRenderer(ren1)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)
ren1.AddActor(planeActor)
ren1.AddActor(glyphActor)
ren1.SetBackground(colors.GetColor3d('White'))
renWin.SetSize(450, 450)
renWin.Render()
iren.Start()
def __init__(self, module_manager):
ModuleBase.__init__(self, module_manager)
# setup config
self._config.toroidal = True
self._config.thickness = 0.3333
self._config.phiRoundness = 0.2
self._config.thetaRoundness = 0.8
self._config.size = 0.5
self._config.center = (0, 0, 0)
self._config.scale = (1, 1, 1)
self._config.thetaResolution = 64
self._config.phiResolution = 64
# and then our scripted config
configList = [
('Toroidal: ', 'toroidal', 'base:bool', 'checkbox',
'Should the quadric be toroidal.'),
('Thickness: ', 'thickness', 'base:float', 'text',
'Thickness of the toroid, scaled between 0 and 1'),
('Phi Roundness: ', 'phiRoundness', 'base:float', 'text',
'Controls shape of superquadric'),
('Theta Roundness: ', 'thetaRoundness', 'base:float', 'text',
'Controls shape of superquadric'),
('Size: ', 'size', 'base:float', 'text',
'The size of the superquadric.'),
('Centre: ', 'center', 'tuple:float,3', 'text',
'The translation transform of the resultant superquadric.'),
('Scale: ', 'scale', 'tuple:float,3', 'text',
'The scale transformof the resultant superquadric.'),
('Theta resolution: ', 'thetaResolution', 'base:int', 'text',
'The resolution of the output polydata'),
('Phi resolution: ', 'phiResolution', 'base:int', 'text',
'The resolution of the output polydata')
]
# now create the necessary VTK modules
self._superquadric = vtk.vtkSuperquadric()
self._superquadricSource = vtk.vtkSuperquadricSource()
# we need these temporary outputs
self._outputs = [self._superquadric, vtk.vtkPolyData()]
# setup progress for the processObject
module_utils.setup_vtk_object_progress(self, self._superquadricSource,
"Synthesizing polydata.")
# mixin ctor
ScriptedConfigModuleMixin.__init__(
self, configList, {
'Module (self)': self,
'vtkSuperquadric': self._superquadric,
'vtkSuperquadricSource': self._superquadricSource
})
self.sync_module_logic_with_config()
def __init__(self, module_manager):
ModuleBase.__init__(self, module_manager)
# setup config
self._config.toroidal = True
self._config.thickness = 0.3333
self._config.phiRoundness = 0.2
self._config.thetaRoundness = 0.8
self._config.size = 0.5
self._config.center = (0,0,0)
self._config.scale = (1,1,1)
self._config.thetaResolution = 64
self._config.phiResolution = 64
# and then our scripted config
configList = [
('Toroidal: ', 'toroidal', 'base:bool', 'checkbox',
'Should the quadric be toroidal.'),
('Thickness: ', 'thickness', 'base:float', 'text',
'Thickness of the toroid, scaled between 0 and 1'),
('Phi Roundness: ', 'phiRoundness', 'base:float', 'text',
'Controls shape of superquadric'),
('Theta Roundness: ', 'thetaRoundness', 'base:float', 'text',
'Controls shape of superquadric'),
('Size: ', 'size', 'base:float', 'text',
'The size of the superquadric.'),
('Centre: ', 'center', 'tuple:float,3', 'text',
'The translation transform of the resultant superquadric.'),
('Scale: ', 'scale', 'tuple:float,3', 'text',
'The scale transformof the resultant superquadric.'),
('Theta resolution: ', 'thetaResolution', 'base:int', 'text',
'The resolution of the output polydata'),
('Phi resolution: ', 'phiResolution', 'base:int', 'text',
'The resolution of the output polydata')]
# now create the necessary VTK modules
self._superquadric = vtk.vtkSuperquadric()
self._superquadricSource = vtk.vtkSuperquadricSource()
# we need these temporary outputs
self._outputs = [self._superquadric, vtk.vtkPolyData()]
# setup progress for the processObject
module_utils.setup_vtk_object_progress(self, self._superquadricSource,
"Synthesizing polydata.")
# mixin ctor
ScriptedConfigModuleMixin.__init__(
self, configList,
{'Module (self)' : self,
'vtkSuperquadric' : self._superquadric,
'vtkSuperquadricSource' : self._superquadricSource})
self.sync_module_logic_with_config()
def __init__(self, thetaresolution, phiresolution, thetaroundness,
phiroundness):
self.tres = thetaresolution
self.phires = phiresolution
self.tround = thetaroundness
self.phiround = phiroundness
self.probe = vtk.vtkProbeFilter()
self.datacutmapper = vtk.vtkPolyDataMapper()
self.dataCutActor = vtk.vtkActor()
self.tensorEllipsoids = vtk.vtkTensorGlyph()
self.superquad = vtk.vtkSuperquadricSource()
def main():
colors = vtk.vtkNamedColors()
# Create a superquadric
superquadricSource = vtk.vtkSuperquadricSource()
superquadricSource.SetPhiRoundness(3.1)
superquadricSource.SetThetaRoundness(1.0)
superquadricSource.Update() # needed to GetBounds later
renderer = vtk.vtkRenderer()
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(superquadricSource.GetOutputPort())
superquadricActor = vtk.vtkActor()
superquadricActor.SetMapper(mapper)
cubeAxesActor = vtk.vtkCubeAxesActor()
cubeAxesActor.SetBounds(superquadricSource.GetOutput().GetBounds())
cubeAxesActor.SetCamera(renderer.GetActiveCamera())
cubeAxesActor.GetTitleTextProperty(0).SetColor(colors.GetColor3d('Red'))
cubeAxesActor.GetLabelTextProperty(0).SetColor(colors.GetColor3d('Red'))
cubeAxesActor.GetTitleTextProperty(1).SetColor(colors.GetColor3d('LimeGreen'))
cubeAxesActor.GetLabelTextProperty(1).SetColor(colors.GetColor3d('LimeGreen'))
cubeAxesActor.GetTitleTextProperty(2).SetColor(colors.GetColor3d('Blue'))
cubeAxesActor.GetLabelTextProperty(2).SetColor(colors.GetColor3d('Blue'))
cubeAxesActor.DrawXGridlinesOn()
cubeAxesActor.DrawYGridlinesOn()
cubeAxesActor.DrawZGridlinesOn()
cubeAxesActor.SetGridLineLocation(cubeAxesActor.VTK_GRID_LINES_FURTHEST)
cubeAxesActor.XAxisMinorTickVisibilityOff()
cubeAxesActor.YAxisMinorTickVisibilityOff()
cubeAxesActor.ZAxisMinorTickVisibilityOff()
renderer.AddActor(cubeAxesActor)
renderer.AddActor(superquadricActor)
renderer.GetActiveCamera().Azimuth(30)
renderer.GetActiveCamera().Elevation(30)
renderer.ResetCamera()
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
renderWindowInteractor.SetRenderWindow(renderWindow)
renderWindow.Render()
renderWindowInteractor.Start()
def GenTorus(programArguments):
''' programArguments: ini file containing model parameters'''
# Load relevant parameters from ini file
conf = ConfigObj(programArguments)
parameters = conf['Parameters']
majorCirc = parameters['surfaceLength']
minorCirc = parameters['surfaceWidth']
thetaMesh = parameters['xMesh']
# Minor and major radii
r = float(minorCirc)/(2*np.pi)
R = float(majorCirc)/(2*np.pi)
# Mesh sizes
thetaResolution = int(thetaMesh)
phiResolution = int(thetaResolution*(R/r))
# Generate a torus
torusSource = vtk.vtkSuperquadricSource()
torusSource.SetCenter(0.0, 0.0, 0.0)
torusSource.SetScale(1.0, 1.0, 1.0)
torusSource.SetToroidal(1)
torusSource.SetThetaRoundness(1)
torusSource.SetPhiRoundness(1)
# SuperquadricSource reverses phi and theta to be confusing - this is not an error
torusSource.SetPhiResolution(thetaResolution)
torusSource.SetThetaResolution(phiResolution)
# Don't change these!
torusSource.SetSize(R + r)
torusSource.SetThickness(r/R)
# The quadric has nasty discontinuities from the way the edges are generated
# so let's pass it though a CleanPolyDataFilter and merge any points which
# are coincident, or very close. First convert quads into triangles
tri = vtk.vtkTriangleFilter()
tri.SetInputConnection(torusSource.GetOutputPort())
cleaner = vtk.vtkCleanPolyData()
cleaner.SetInputConnection(tri.GetOutputPort())
cleaner.SetTolerance(0.00005)
cleaner.Update()
outputFileName = "torus_R" + majorCirc + "_r" + minorCirc + "_mesh" + thetaMesh + ".vtp"
writer = vtk.vtkXMLPolyDataWriter()
writer.SetInputData(cleaner.GetOutput())
writer.SetFileName(outputFileName)
writer.Update()
print "Saving output to file", outputFileName
def make_polydata_actor(centers, normals, return_pdm=False, type='circle'):
""" Create the actor and set colors
:param return_pdm: if True give back the polydatamapper
:param centers: list of centers as tuples
:param normals: list of list of normals as tuples
"""
# In order to build the bounding box it is convenient to combine
# All sources using a vtkAppenPolyData
apd = vtk.vtkAppendPolyData()
mappers = []
# create source
for i in range(len(centers)):
normal = normals[i]
if normal is None:
source = vtk.vtkSphereSource()
source.SetRadius(80)
else:
if type=='torus':
source = vtk.vtkSuperquadricSource();
source.SetScale(1.0, 1.0, 1.0)
source.SetPhiResolution (16)
source.SetThetaResolution(16)
source.SetThetaRoundness (1)
source.SetThickness (0.1)
source.SetSize(100.5)
source.SetToroidal(1)
source.SetNormal(normal)
elif type=='circle':
source = vtk.vtkRegularPolygonSource()
source.SetNumberOfSides(16)
source.SetRadius(100)
source.SetNormal(normal)
source.SetCenter(*centers[i])
apd.AddInput(source.GetOutput())
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(apd.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
if return_pdm:
return actor, apd
else:
return actor
def make_polydata_actor(centers, normals, return_pdm=False, type='circle'):
""" Create the actor and set colors
:param return_pdm: if True give back the polydatamapper
:param centers: list of centers as tuples
:param normals: list of list of normals as tuples
"""
# In order to build the bounding box it is convenient to combine
# All sources using a vtkAppenPolyData
apd = vtk.vtkAppendPolyData()
mappers = []
# create source
for i in range(len(centers)):
normal = normals[i]
if normal is None:
source = vtk.vtkSphereSource()
source.SetRadius(80)
else:
if type == 'torus':
source = vtk.vtkSuperquadricSource()
source.SetScale(1.0, 1.0, 1.0)
source.SetPhiResolution(16)
source.SetThetaResolution(16)
source.SetThetaRoundness(1)
source.SetThickness(0.1)
source.SetSize(100.5)
source.SetToroidal(1)
source.SetNormal(normal)
elif type == 'circle':
source = vtk.vtkRegularPolygonSource()
source.SetNumberOfSides(16)
source.SetRadius(100)
source.SetNormal(normal)
source.SetCenter(*centers[i])
apd.AddInput(source.GetOutput())
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(apd.GetOutputPort())
actor = vtk.vtkActor()
actor.SetMapper(mapper)
if return_pdm:
return actor, apd
else:
return actor
def __init__(self, parent, id):
# create wx.Frame and wxVTKRenderWindowInteractor to put in it
wx.Frame.__init__(self, parent, id, "DRE wxVTK demo", size=(400, 400))
# create a menu
menuBar = wx.MenuBar()
menu = wx.Menu()
quitMenu = menu.Append(-1, "&Quit", "Quit")
self.Bind(wx.EVT_MENU, self.onQuit, quitMenu)
menuBar.Append(menu, "&File")
self.SetMenuBar(menuBar)
# create a donut polydata source
superquadric = vtk.vtkSuperquadricSource()
superquadric.ToroidalOn()
# connect it to Polydatamapper
m = vtk.vtkPolyDataMapper()
m.SetInput(superquadric.GetOutput())
# create an actor to represent the donut in the scene
a = vtk.vtkActor()
a.SetMapper(m)
a.GetProperty().SetColor(0.8, 0.5, 0.3)
a.GetProperty().SetSpecular(0.3)
# the render is a 3D Scene
self.ren = vtk.vtkRenderer()
self.ren.AddActor(a)
self.ren.SetBackground(0.2, 0.5, 0.7)
#make sure the RWI sizes to fill the frame
self.rwi = wxVTKRenderWindow(self, -1)
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(self.rwi, 1, wx.EXPAND)
self.SetSizer(sizer)
self.Layout()
# sequence of init is different
self.rwi.Enable(1)
# add created renderer to the RWI's buit-in renderer window
self.rwi.GetRenderWindow().AddRenderer(self.ren)
def __init__(self, parent, id):
# create wx.Frame and wxVTKRenderWindowInteractor to put in it
wx.Frame.__init__(self, parent, id, "DRE wxVTK demo", size=(400,400))
# create a menu
menuBar = wx.MenuBar()
menu = wx.Menu()
quitMenu = menu.Append(-1, "&Quit", "Quit")
self.Bind(wx.EVT_MENU, self.onQuit, quitMenu)
menuBar.Append(menu, "&File")
self.SetMenuBar(menuBar)
# create a donut polydata source
superquadric = vtk.vtkSuperquadricSource()
superquadric.ToroidalOn()
# connect it to Polydatamapper
m = vtk.vtkPolyDataMapper()
m.SetInput(superquadric.GetOutput())
# create an actor to represent the donut in the scene
a = vtk.vtkActor()
a.SetMapper(m)
a.GetProperty().SetColor(0.8, 0.5, 0.3)
a.GetProperty().SetSpecular(0.3)
# the render is a 3D Scene
self.ren = vtk.vtkRenderer()
self.ren.AddActor(a)
self.ren.SetBackground(0.2, 0.5, 0.7)
#make sure the RWI sizes to fill the frame
self.rwi = wxVTKRenderWindow(self, -1)
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(self.rwi, 1, wx.EXPAND)
self.SetSizer(sizer)
self.Layout()
# sequence of init is different
self.rwi.Enable(1)
# add created renderer to the RWI's buit-in renderer window
self.rwi.GetRenderWindow().AddRenderer(self.ren)
def testICPTransform(self):
renWin = vtk.vtkRenderWindow()
#iren = vtk.vtkRenderWindowInteractor()
#iren.SetRenderWindow(renWin)
# Create objects
sscale = {2:[0.7, 0.7, 0.7],
3:[0.5, 0.5, 0.5]}
scenter = {2:[-0.25, 0.25, 0.0],
3:[ 0.4, -0.3, 0.0]}
scolors = {2:[0.2, 0.6, 0.1],
3:[0.1, 0.2, 0.6]}
s = dict() # The super quadric sources
for sidx in range(1, 4):
s.update({sidx:vtk.vtkSuperquadricSource()})
s[sidx].ToroidalOff()
s[sidx].SetThetaResolution(20)
s[sidx].SetPhiResolution(20)
s[sidx].SetPhiRoundness(0.7 + (sidx - 2) * 0.4)
s[sidx].SetThetaRoundness(0.85 + (sidx - 1) * 0.4)
if sidx in sscale:
s[sidx].SetScale(sscale[sidx])
if sidx in scenter:
s[sidx].SetCenter(scenter[sidx])
s[sidx].Update()
ren = dict() # Renderers
sm = dict() # Mappers for the super quadric source
sa = dict() # Actors for the super quadric source
fe = dict() # Feature edges
fem = dict() # Feature edges mappers
fea = dict() # Feature edges actors
icp = dict() # Iterated closest point transforms
# Create the renderers
for ridx in range(1, 4):
ren.update({ridx: vtk.vtkRenderer()})
ren[ridx].SetViewport((ridx - 1) / 3.0, 0.0, ridx / 3.0, 1.0)
ren[ridx].SetBackground(0.7, 0.8, 1.0)
cam = ren[ridx].GetActiveCamera()
cam.SetPosition(1.7, 1.4, 1.7)
renWin.AddRenderer(ren[ridx])
# renderer 1 has all 3 objects, render i has object 1 and i (i=2, 3)
# add actors (corresponding to the objects) to each renderer
# and ICP transforms from objects i or to 1.
# object 1 has feature edges too.
for sidx in range(1, 4):
if ridx == 1 or sidx == 1 or ridx == sidx:
sm.update({ridx:{sidx:vtk.vtkPolyDataMapper()}})
sm[ridx][sidx].SetInputConnection(s[sidx].GetOutputPort())
sa.update({ridx:{sidx:vtk.vtkActor()}})
sa[ridx][sidx].SetMapper(sm[ridx][sidx])
prop = sa[ridx][sidx].GetProperty()
if sidx in scolors:
prop.SetColor(scolors[sidx])
if sidx == 1:
prop.SetOpacity(0.2)
fe.update({ridx:{sidx:vtk.vtkFeatureEdges()}})
src = s[sidx]
fe[ridx][sidx].SetInputConnection(src.GetOutputPort())
fe[ridx][sidx].BoundaryEdgesOn()
fe[ridx][sidx].ColoringOff()
fe[ridx][sidx].ManifoldEdgesOff()
fem.update({ridx:{sidx:vtk.vtkPolyDataMapper()}})
fem[ridx][sidx].SetInputConnection(fe[ridx][sidx].GetOutputPort())
fem[ridx][sidx].SetResolveCoincidentTopologyToPolygonOffset()
fea.update({ridx:{sidx:vtk.vtkActor()}})
fea[ridx][sidx].SetMapper(fem[ridx][sidx])
ren[ridx].AddActor(fea[ridx][sidx])
ren[ridx].AddActor(sa[ridx][sidx])
if ridx > 1 and ridx == sidx:
icp.update({ridx:{sidx:vtk.vtkIterativeClosestPointTransform()}})
icp[ridx][sidx].SetSource(s[sidx].GetOutput())
icp[ridx][sidx].SetTarget(s[1].GetOutput())
icp[ridx][sidx].SetCheckMeanDistance(1)
icp[ridx][sidx].SetMaximumMeanDistance(0.001)
icp[ridx][sidx].SetMaximumNumberOfIterations(30)
icp[ridx][sidx].SetMaximumNumberOfLandmarks(50)
sa[ridx][sidx].SetUserTransform(icp[ridx][sidx])
icp[3][3].StartByMatchingCentroidsOn()
renWin.SetSize(400, 100)
# render and interact with data
iRen = vtk.vtkRenderWindowInteractor()
iRen.SetRenderWindow(renWin);
renWin.Render()
img_file = "TestICPTransform.png"
vtk.test.Testing.compareImage(iRen.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file), threshold=25)
vtk.test.Testing.interact()
def main(argv):
# Verify input arguments
if len(argv) > 1:
# Read the image
jpeg_reader = vtkJPEGReader()
if not jpeg_reader.CanReadFile(argv[1]):
print("Error reading file %s" % argv[1])
return
jpeg_reader.SetFileName(argv[1])
jpeg_reader.Update()
image_data = jpeg_reader.GetOutput()
else:
canvas_source = vtk.vtkImageCanvasSource2D()
canvas_source.SetExtent(0, 100, 0, 100, 0, 0)
canvas_source.SetScalarTypeToUnsignedChar()
canvas_source.SetNumberOfScalarComponents(3)
canvas_source.SetDrawColor(127, 127, 100)
canvas_source.FillBox(0, 100, 0, 100)
canvas_source.SetDrawColor(100, 255, 255)
canvas_source.FillTriangle(10, 10, 25, 10, 25, 25)
canvas_source.SetDrawColor(255, 100, 255)
canvas_source.FillTube(75, 75, 0, 75, 5.0)
canvas_source.Update()
image_data = canvas_source.GetOutput()
# Create an image actor to display the image
image_actor = vtkImageActor()
if VTK_MAJOR_VERSION <= 5:
image_actor.SetInput(image_data)
else:
image_actor.SetInputData(image_data)
# Create a superquadric
superquadric_source = vtkSuperquadricSource()
superquadric_source.SetPhiRoundness(1.1)
superquadric_source.SetThetaRoundness(.2)
# Create a mapper and actor
superquadric_mapper = vtkPolyDataMapper()
superquadric_mapper.SetInputConnection(superquadric_source.GetOutputPort())
superquadric_actor = vtkActor()
superquadric_actor.SetMapper(superquadric_mapper)
vtk_renderer = vtkRenderer()
vtk_renderer.SetLayer(1)
# Set up the render window and renderers such that there is
# a background layer and a foreground layer
background_renderer = vtkRenderer()
background_renderer.SetLayer(0)
background_renderer.InteractiveOff()
background_renderer.AddActor(image_actor)
render_window = vtkRenderWindow()
render_window.SetNumberOfLayers(2)
render_window.AddRenderer(background_renderer)
render_window.AddRenderer(vtk_renderer)
render_window_interactor = vtkRenderWindowInteractor()
render_window_interactor.SetRenderWindow(render_window)
# Add actors to the renderers
vtk_renderer.AddActor(superquadric_actor)
# Render once to figure out where the background camera will be
render_window.Render()
# Set up the background camera to fill the renderer with the image
origin = image_data.GetOrigin()
spacing = image_data.GetSpacing()
extent = image_data.GetExtent()
camera = background_renderer.GetActiveCamera()
camera.ParallelProjectionOn()
xc = origin[0] + 0.5*(extent[0] + extent[1]) * spacing[0]
yc = origin[1] + 0.5*(extent[2] + extent[3]) * spacing[1]
# xd = (extent[1] - extent[0] + 1) * spacing[0]
yd = (extent[3] - extent[2] + 1) * spacing[1]
d = camera.GetDistance()
camera.SetParallelScale(0.5 * yd)
camera.SetFocalPoint(xc, yc, 0.0)
camera.SetPosition(xc, yc, d)
# Render again to set the correct view
render_window.Render()
# Interact with the window
render_window_interactor.Start()
def rerender():
ret, frame = cap.read()
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
img = convert_to_vtk(gray)
image_actor = vtkImageActor()
image_actor.SetInputData(img)
background_renderer = vtkRenderer()
background_renderer.SetLayer(0)
render_window.AddRenderer(background_renderer)
background_renderer.AddActor(image_actor)
render_window.Render()
cap = cv2.VideoCapture(0)
superquadric_source = vtkSuperquadricSource()
superquadric_source.SetPhiRoundness(1.1)
superquadric_source.SetThetaRoundness(.4)
superquadric_mapper = vtkPolyDataMapper()
superquadric_mapper.SetInputConnection(superquadric_source.GetOutputPort())
superquadric_actor = vtkActor()
superquadric_actor.SetMapper(superquadric_mapper)
scene_renderer = vtkRenderer()
render_window = vtkRenderWindow()
scene_renderer.SetLayer(1)
render_window.SetNumberOfLayers(2)
render_window.AddRenderer(scene_renderer)
render_window_interactor = vtkRenderWindowInteractor()
render_window_interactor.SetRenderWindow(render_window)
scene_renderer.AddActor(superquadric_actor)
def __init__(self, parent = None):
super(VTKFrame, self).__init__(parent)
self.vtkWidget = QVTKRenderWindowInteractor(self)
self.iren = self.vtkWidget.GetRenderWindow().GetInteractor()
vl = QtGui.QVBoxLayout(self)
vl.addWidget(self.vtkWidget)
vl.setContentsMargins(0, 0, 0, 0)
# Create source
# We are going to handle two different sources.
# The first source is a superquadric source.
torus = vtk.vtkSuperquadricSource();
torus.SetCenter(0.0, 0.0, 0.0)
torus.SetScale(1.0, 1.0, 1.0)
torus.SetPhiResolution (64)
torus.SetThetaResolution(64)
torus.SetThetaRoundness (1)
torus.SetThickness (0.5)
torus.SetSize(0.5)
torus.SetToroidal(1)
# Rotate the torus towards the observer (around the x-axis)
torusT = vtk.vtkTransform()
torusT.RotateX(55)
torusTF = vtk.vtkTransformFilter()
torusTF.SetInputConnection(torus.GetOutputPort())
torusTF.SetTransform(torusT)
# The quadric is made of strips, so pass it through a triangle filter as
# the curvature filter only operates on polys
tri = vtk.vtkTriangleFilter()
tri.SetInputConnection(torusTF.GetOutputPort())
# The quadric has nasty discontinuities from the way the edges are generated
# so let's pass it though a CleanPolyDataFilter and merge any points which
# are coincident, or very close
cleaner = vtk.vtkCleanPolyData()
cleaner.SetInputConnection(tri.GetOutputPort())
cleaner.SetTolerance(0.005)
# The next source will be a parametric function
rh = vtk.vtkParametricRandomHills()
rhFnSrc = vtk.vtkParametricFunctionSource()
rhFnSrc.SetParametricFunction(rh)
# Now we have the sources, lets put them into a list.
sources = list()
sources.append(cleaner)
sources.append(cleaner)
sources.append(rhFnSrc)
sources.append(rhFnSrc)
# Colour transfer function.
ctf = vtk.vtkColorTransferFunction()
ctf.SetColorSpaceToDiverging()
ctf.AddRGBPoint(0.0, 0.230, 0.299, 0.754)
ctf.AddRGBPoint(1.0, 0.706, 0.016, 0.150)
cc = list()
for i in range(256):
cc.append(ctf.GetColor(float(i) / 255.0))
# Lookup table.
lut = list()
for idx in range(len(sources)):
lut.append(vtk.vtkLookupTable())
lut[idx].SetNumberOfColors(256)
for i, item in enumerate(cc):
lut[idx].SetTableValue(i, item[0], item[1], item[2], 1.0)
if idx == 0:
lut[idx].SetRange(-10, 10)
if idx == 1:
lut[idx].SetRange(0, 4)
if idx == 2:
lut[idx].SetRange(-1, 1)
if idx == 3:
lut[idx].SetRange(-1, 1)
lut[idx].Build()
curvatures = list()
for idx in range(len(sources)):
curvatures.append(vtk.vtkCurvatures())
if idx % 2 == 0:
curvatures[idx].SetCurvatureTypeToGaussian()
else:
curvatures[idx].SetCurvatureTypeToMean()
renderers = list()
mappers = list()
actors = list()
textmappers = list()
textactors = list()
# Create a common text property.
textProperty = vtk.vtkTextProperty()
textProperty.SetFontSize(10)
textProperty.SetJustificationToCentered()
names = ['Torus - Gaussian Curvature', 'Torus - Mean Curvature', 'Random Hills - Gaussian Curvature', 'Random Hills - Mean Curvature']
# Link the pipeline together.
for idx, item in enumerate(sources):
sources[idx].Update()
curvatures[idx].SetInputConnection(sources[idx].GetOutputPort())
mappers.append(vtk.vtkPolyDataMapper())
mappers[idx].SetInputConnection(curvatures[idx].GetOutputPort())
mappers[idx].SetLookupTable(lut[idx])
mappers[idx].SetUseLookupTableScalarRange(1)
actors.append(vtk.vtkActor())
actors[idx].SetMapper(mappers[idx])
textmappers.append(vtk.vtkTextMapper())
textmappers[idx].SetInput(names[idx])
textmappers[idx].SetTextProperty(textProperty)
textactors.append(vtk.vtkActor2D())
textactors[idx].SetMapper(textmappers[idx])
textactors[idx].SetPosition(150, 16)
renderers.append(vtk.vtkRenderer())
gridDimensions = 2
for idx in range(len(sources)):
if idx < gridDimensions * gridDimensions:
renderers.append(vtk.vtkRenderer)
rendererSize = 300
# Create the RenderWindow
self.vtkWidget.GetRenderWindow().SetSize(rendererSize * gridDimensions, rendererSize * gridDimensions)
# Add and position the renders to the render window.
viewport = list()
for row in range(gridDimensions):
for col in range(gridDimensions):
idx = row * gridDimensions + col
viewport[:] = []
viewport.append(float(col) * rendererSize / (gridDimensions * rendererSize))
viewport.append(float(gridDimensions - (row+1)) * rendererSize / (gridDimensions * rendererSize))
viewport.append(float(col+1)*rendererSize / (gridDimensions * rendererSize))
viewport.append(float(gridDimensions - row) * rendererSize / (gridDimensions * rendererSize))
if idx > (len(sources) - 1):
continue
renderers[idx].SetViewport(viewport)
self.vtkWidget.GetRenderWindow().AddRenderer(renderers[idx])
renderers[idx].AddActor(actors[idx])
renderers[idx].AddActor(textactors[idx])
renderers[idx].SetBackground(0.4,0.3,0.2)
self._initialized = False
def main():
colors = vtk.vtkNamedColors()
file_name = get_program_parameters()
# Read the polydata for the icon
reader = vtk.vtkXMLPolyDataReader()
reader.SetFileName(file_name)
icon_mapper = vtk.vtkDataSetMapper()
icon_mapper.SetInputConnection(reader.GetOutputPort())
icon_actor = vtk.vtkActor()
icon_actor.SetMapper(icon_mapper)
icon_actor.GetProperty().SetColor(colors.GetColor3d('Silver'))
# Set up the renderer, window, and interactor
renderer = vtk.vtkRenderer()
renderer.SetBackground(colors.GetColor3d('SlateGray'))
ren_win = vtk.vtkRenderWindow()
ren_win.AddRenderer(renderer)
ren_win.SetSize(400, 400)
ren_win.SetWindowName('OrientationMarkerWidget1')
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(ren_win)
rgb = [0.0, 0.0, 0.0]
colors.GetColorRGB('Wheat', rgb)
# Set up the widget
widget = vtk.vtkOrientationMarkerWidget()
widget.SetOrientationMarker(icon_actor)
widget.SetInteractor(iren)
widget.SetViewport(0.0, 0.0, 0.2, 0.2)
widget.SetOutlineColor(*rgb)
widget.SetEnabled(1)
widget.InteractiveOn()
# Create a superquadric
superquadric_source = vtk.vtkSuperquadricSource()
superquadric_source.SetPhiRoundness(.2)
superquadric_source.SetThetaRoundness(.8)
# Create a mapper and actor
superquadric_mapper = vtk.vtkPolyDataMapper()
superquadric_mapper.SetInputConnection(superquadric_source.GetOutputPort())
superquadric_actor = vtk.vtkActor()
superquadric_actor.SetMapper(superquadric_mapper)
superquadric_actor.GetProperty().SetInterpolationToFlat()
superquadric_actor.GetProperty().SetDiffuseColor(
colors.GetColor3d('Carrot'))
superquadric_actor.GetProperty().SetSpecularColor(
colors.GetColor3d('White'))
superquadric_actor.GetProperty().SetDiffuse(0.6)
superquadric_actor.GetProperty().SetSpecular(0.5)
superquadric_actor.GetProperty().SetSpecularPower(5.0)
renderer.AddActor(superquadric_actor)
renderer.ResetCamera()
ren_win.Render()
iren.Initialize()
iren.Start()
def main():
colors = vtk.vtkNamedColors()
# Verify input arguments
fn = get_program_parameters()
if fn:
# Read the image
jpeg_reader = vtk.vtkJPEGReader()
if not jpeg_reader.CanReadFile(fn):
print('Error reading file:', fn)
return
jpeg_reader.SetFileName(fn)
jpeg_reader.Update()
image_data = jpeg_reader.GetOutput()
else:
canvas_source = vtk.vtkImageCanvasSource2D()
canvas_source.SetExtent(0, 100, 0, 100, 0, 0)
canvas_source.SetScalarTypeToUnsignedChar()
canvas_source.SetNumberOfScalarComponents(3)
canvas_source.SetDrawColor(colors.GetColor4ub('warm_grey'))
canvas_source.FillBox(0, 100, 0, 100)
canvas_source.SetDrawColor(colors.GetColor4ub('DarkCyan'))
canvas_source.FillTriangle(10, 10, 25, 10, 25, 25)
canvas_source.SetDrawColor(colors.GetColor4ub('LightCoral'))
canvas_source.FillTube(75, 75, 0, 75, 5.0)
canvas_source.Update()
image_data = canvas_source.GetOutput()
# Create an image actor to display the image
image_actor = vtk.vtkImageActor()
image_actor.SetInputData(image_data)
# Create a renderer to display the image in the background
background_renderer = vtk.vtkRenderer()
# Create a superquadric
superquadric_source = vtk.vtkSuperquadricSource()
superquadric_source.SetPhiRoundness(1.1)
superquadric_source.SetThetaRoundness(.2)
# Create a mapper and actor
superquadric_mapper = vtk.vtkPolyDataMapper()
superquadric_mapper.SetInputConnection(superquadric_source.GetOutputPort())
superquadric_actor = vtk.vtkActor()
superquadric_actor.SetMapper(superquadric_mapper)
superquadric_actor.GetProperty().SetColor(colors.GetColor3d('NavajoWhite'))
scene_renderer = vtk.vtkRenderer()
render_window = vtk.vtkRenderWindow()
# Set up the render window and renderers such that there is
# a background layer and a foreground layer
background_renderer.SetLayer(0)
background_renderer.InteractiveOff()
scene_renderer.SetLayer(1)
render_window.SetNumberOfLayers(2)
render_window.AddRenderer(background_renderer)
render_window.AddRenderer(scene_renderer)
render_window.SetWindowName('BackgroundImage')
render_window_interactor = vtk.vtkRenderWindowInteractor()
render_window_interactor.SetRenderWindow(render_window)
# Add actors to the renderers
scene_renderer.AddActor(superquadric_actor)
background_renderer.AddActor(image_actor)
# Render once to figure out where the background camera will be
render_window.Render()
# Set up the background camera to fill the renderer with the image
origin = image_data.GetOrigin()
spacing = image_data.GetSpacing()
extent = image_data.GetExtent()
camera = background_renderer.GetActiveCamera()
camera.ParallelProjectionOn()
xc = origin[0] + 0.5 * (extent[0] + extent[1]) * spacing[0]
yc = origin[1] + 0.5 * (extent[2] + extent[3]) * spacing[1]
# xd = (extent[1] - extent[0] + 1) * spacing[0]
yd = (extent[3] - extent[2] + 1) * spacing[1]
d = camera.GetDistance()
camera.SetParallelScale(0.5 * yd)
camera.SetFocalPoint(xc, yc, 0.0)
camera.SetPosition(xc, yc, d)
# Render again to set the correct view
render_window.Render()
# Interact with the window
render_window_interactor.Start()
def main():
colors = vtk.vtkNamedColors()
backgroundColor = colors.GetColor3d("DarkSlateGray")
actorColor = colors.GetColor3d("Tomato")
axis1Color = colors.GetColor3d("Salmon")
axis2Color = colors.GetColor3d("PaleGreen")
axis3Color = colors.GetColor3d("LightSkyBlue")
# Create a superquadric
superquadricSource = vtk.vtkSuperquadricSource()
superquadricSource.SetPhiRoundness(3.1)
superquadricSource.SetThetaRoundness(1.0)
superquadricSource.Update() # needed to GetBounds later
renderer = vtk.vtkRenderer()
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(superquadricSource.GetOutputPort())
superquadricActor = vtk.vtkActor()
superquadricActor.SetMapper(mapper)
superquadricActor.GetProperty().SetDiffuseColor(actorColor)
superquadricActor.GetProperty().SetDiffuse(.7)
superquadricActor.GetProperty().SetSpecular(.7)
superquadricActor.GetProperty().SetSpecularPower(50.0)
cubeAxesActor = vtk.vtkCubeAxesActor()
cubeAxesActor.SetUseTextActor3D(1)
cubeAxesActor.SetBounds(superquadricSource.GetOutput().GetBounds())
cubeAxesActor.SetCamera(renderer.GetActiveCamera())
cubeAxesActor.GetTitleTextProperty(0).SetColor(axis1Color)
cubeAxesActor.GetTitleTextProperty(0).SetFontSize(48)
cubeAxesActor.GetLabelTextProperty(0).SetColor(axis1Color)
cubeAxesActor.GetTitleTextProperty(1).SetColor(axis2Color)
cubeAxesActor.GetLabelTextProperty(1).SetColor(axis2Color)
cubeAxesActor.GetTitleTextProperty(2).SetColor(axis3Color)
cubeAxesActor.GetLabelTextProperty(2).SetColor(axis3Color)
cubeAxesActor.DrawXGridlinesOn()
cubeAxesActor.DrawYGridlinesOn()
cubeAxesActor.DrawZGridlinesOn()
cubeAxesActor.SetGridLineLocation(cubeAxesActor.VTK_GRID_LINES_FURTHEST)
cubeAxesActor.XAxisMinorTickVisibilityOff()
cubeAxesActor.YAxisMinorTickVisibilityOff()
cubeAxesActor.ZAxisMinorTickVisibilityOff()
cubeAxesActor.SetFlyModeToStaticEdges()
renderer.AddActor(cubeAxesActor)
renderer.AddActor(superquadricActor)
renderer.GetActiveCamera().Azimuth(30)
renderer.GetActiveCamera().Elevation(30)
renderer.ResetCamera()
renderer.SetBackground(backgroundColor)
renderWindow = vtk.vtkRenderWindow()
renderWindow.AddRenderer(renderer)
renderWindow.SetSize(640, 480)
renderWindow.SetWindowName('CubeAxesActor')
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
renderWindowInteractor.SetRenderWindow(renderWindow)
renderWindow.Render()
renderer.GetActiveCamera().Zoom(0.8)
renderWindowInteractor.Start()
def testICPTransform(self):
renWin = vtk.vtkRenderWindow()
#iren = vtk.vtkRenderWindowInteractor()
#iren.SetRenderWindow(renWin)
# Create objects
sscale = {2: [0.7, 0.7, 0.7], 3: [0.5, 0.5, 0.5]}
scenter = {2: [-0.25, 0.25, 0.0], 3: [0.4, -0.3, 0.0]}
scolors = {2: [0.2, 0.6, 0.1], 3: [0.1, 0.2, 0.6]}
s = dict() # The super quadric sources
for sidx in range(1, 4):
s.update({sidx: vtk.vtkSuperquadricSource()})
s[sidx].ToroidalOff()
s[sidx].SetThetaResolution(20)
s[sidx].SetPhiResolution(20)
s[sidx].SetPhiRoundness(0.7 + (sidx - 2) * 0.4)
s[sidx].SetThetaRoundness(0.85 + (sidx - 1) * 0.4)
if sidx in sscale:
s[sidx].SetScale(sscale[sidx])
if sidx in scenter:
s[sidx].SetCenter(scenter[sidx])
s[sidx].Update()
ren = dict() # Renderers
sm = dict() # Mappers for the super quadric source
sa = dict() # Actors for the super quadric source
fe = dict() # Feature edges
fem = dict() # Feature edges mappers
fea = dict() # Feature edges actors
icp = dict() # Iterated closest point transforms
# Create the renderers
for ridx in range(1, 4):
ren.update({ridx: vtk.vtkRenderer()})
ren[ridx].SetViewport((ridx - 1) / 3.0, 0.0, ridx / 3.0, 1.0)
ren[ridx].SetBackground(0.7, 0.8, 1.0)
cam = ren[ridx].GetActiveCamera()
cam.SetPosition(1.7, 1.4, 1.7)
renWin.AddRenderer(ren[ridx])
# renderer 1 has all 3 objects, render i has object 1 and i (i=2, 3)
# add actors (corresponding to the objects) to each renderer
# and ICP transforms from objects i or to 1.
# object 1 has feature edges too.
for sidx in range(1, 4):
if ridx == 1 or sidx == 1 or ridx == sidx:
sm.update({ridx: {sidx: vtk.vtkPolyDataMapper()}})
sm[ridx][sidx].SetInputConnection(s[sidx].GetOutputPort())
sa.update({ridx: {sidx: vtk.vtkActor()}})
sa[ridx][sidx].SetMapper(sm[ridx][sidx])
prop = sa[ridx][sidx].GetProperty()
if sidx in scolors:
prop.SetColor(scolors[sidx])
if sidx == 1:
prop.SetOpacity(0.2)
fe.update({ridx: {sidx: vtk.vtkFeatureEdges()}})
src = s[sidx]
fe[ridx][sidx].SetInputConnection(src.GetOutputPort())
fe[ridx][sidx].BoundaryEdgesOn()
fe[ridx][sidx].ColoringOff()
fe[ridx][sidx].ManifoldEdgesOff()
fem.update({ridx: {sidx: vtk.vtkPolyDataMapper()}})
fem[ridx][sidx].SetInputConnection(
fe[ridx][sidx].GetOutputPort())
fem[ridx][
sidx].SetResolveCoincidentTopologyToPolygonOffset(
)
fea.update({ridx: {sidx: vtk.vtkActor()}})
fea[ridx][sidx].SetMapper(fem[ridx][sidx])
ren[ridx].AddActor(fea[ridx][sidx])
ren[ridx].AddActor(sa[ridx][sidx])
if ridx > 1 and ridx == sidx:
icp.update({
ridx: {
sidx: vtk.vtkIterativeClosestPointTransform()
}
})
icp[ridx][sidx].SetSource(s[sidx].GetOutput())
icp[ridx][sidx].SetTarget(s[1].GetOutput())
icp[ridx][sidx].SetCheckMeanDistance(1)
icp[ridx][sidx].SetMaximumMeanDistance(0.001)
icp[ridx][sidx].SetMaximumNumberOfIterations(30)
icp[ridx][sidx].SetMaximumNumberOfLandmarks(50)
sa[ridx][sidx].SetUserTransform(icp[ridx][sidx])
icp[3][3].StartByMatchingCentroidsOn()
renWin.SetSize(400, 100)
# render and interact with data
iRen = vtk.vtkRenderWindowInteractor()
iRen.SetRenderWindow(renWin)
renWin.Render()
img_file = "TestICPTransform.png"
vtk.test.Testing.compareImage(
iRen.GetRenderWindow(),
vtk.test.Testing.getAbsImagePath(img_file),
threshold=25)
vtk.test.Testing.interact()
def main():
# Create a superquadric
superquadric_source = vtk.vtkSuperquadricSource()
superquadric_source.SetPhiRoundness(3.1)
superquadric_source.SetThetaRoundness(2.2)
# Define a clipping plane
clip_plane = vtk.vtkPlane()
clip_plane.SetNormal(1.0, -1.0, -1.0)
clip_plane.SetOrigin(0.0, 0.0, 0.0)
# Clip the source with the plane
clipper = vtk.vtkClipPolyData()
clipper.SetInputConnection(superquadric_source.GetOutputPort())
clipper.SetClipFunction(clip_plane)
# This will give us the polygonal data that is clipped away
clipper.GenerateClippedOutputOn()
# Create a mapper and actor
superquadric_mapper = vtk.vtkPolyDataMapper()
superquadric_mapper.SetInputConnection(clipper.GetOutputPort())
superquadric_actor = vtk.vtkActor()
superquadric_actor.SetMapper(superquadric_mapper)
colors = vtk.vtkNamedColors()
# Create a property to be used for the back faces. Turn off all
# shading by specifying 0 weights for specular and diffuse. Max the
# ambient.
back_faces = vtk.vtkProperty()
back_faces.SetSpecular(0.0)
back_faces.SetDiffuse(0.0)
back_faces.SetAmbient(1.0)
back_faces.SetAmbientColor(colors.GetColor3d('Tomato'))
superquadric_actor.SetBackfaceProperty(back_faces)
# Here we get the the polygonal data that is clipped away
clipped_away_mapper = vtk.vtkPolyDataMapper()
clipped_away_mapper.SetInputData(clipper.GetClippedOutput())
clipped_away_mapper.ScalarVisibilityOff()
# Let us display it as a faint object
clipped_away_actor = vtk.vtkActor()
clipped_away_actor.SetMapper(clipped_away_mapper)
clipped_away_actor.GetProperty().SetDiffuseColor(
colors.GetColor3d("Silver"))
clipped_away_actor.GetProperty().SetOpacity(0.1)
# Create a renderer
renderer = vtk.vtkRenderer()
renderer.SetBackground(colors.GetColor3d('SlateGray'))
render_window = vtk.vtkRenderWindow()
render_window.AddRenderer(renderer)
render_window_interactor = vtk.vtkRenderWindowInteractor()
render_window_interactor.SetRenderWindow(render_window)
# Add the actor to the renderer
renderer.AddActor(superquadric_actor)
renderer.AddActor(clipped_away_actor)
render_window.SetSize(600, 600)
renderer.ResetCamera()
renderer.GetActiveCamera().Dolly(1.5)
renderer.ResetCameraClippingRange()
render_window.Render()
render_window.SetWindowName('SolidClip')
# Interact with the window
render_window_interactor.Start()
import vtk
reader = vtk.vtkSTLReader()
reader.SetFileName("skull.stl")
sphere = vtk.vtkSuperquadricSource()
sphere.ToroidalOn()
sphere.SetThetaResolution(50)
sphere.SetPhiResolution(50)
mapper = vtk.vtkOpenGLPolyDataMapper()
mapper.SetInputConnection(sphere.GetOutputPort())
mapper.SetVertexShaderCode("""
#version 330
uniform mat4 modelViewMatrix;
uniform mat4 modelMatrix;
uniform mat4 viewMatrix;
uniform mat4 projectionMatrix;
uniform mat4 textureMatrix;
uniform mat4 modelViewProjectionMatrix;
uniform mat4 normalMatrix;
in vec4 position;
in vec4 color;
in vec4 normal;
in vec2 texcoord;
in vec3 n;
in vec3 l;
#!/usr/bin/env python import vtk # Create a superquadric superquadricSource = vtk.vtkSuperquadricSource() superquadricSource.SetPhiRoundness(3.1) superquadricSource.SetThetaRoundness(1.0) superquadricSource.Update() # needed to GetBounds later renderer = vtk.vtkRenderer() mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(superquadricSource.GetOutputPort()) superquadricActor = vtk.vtkActor() superquadricActor.SetMapper(mapper) cubeAxesActor = vtk.vtkCubeAxesActor() cubeAxesActor.SetBounds(superquadricSource.GetOutput().GetBounds()) cubeAxesActor.SetCamera(renderer.GetActiveCamera()) cubeAxesActor.GetTitleTextProperty(0).SetColor(1.0, 0.0, 0.0) cubeAxesActor.GetLabelTextProperty(0).SetColor(1.0, 0.0, 0.0) cubeAxesActor.GetTitleTextProperty(1).SetColor(0.0, 1.0, 0.0) cubeAxesActor.GetLabelTextProperty(1).SetColor(0.0, 1.0, 0.0) cubeAxesActor.GetTitleTextProperty(2).SetColor(0.0, 0.0, 1.0) cubeAxesActor.GetLabelTextProperty(2).SetColor(0.0, 0.0, 1.0) cubeAxesActor.DrawXGridlinesOn()
def main(argv):
colors = vtk.vtkNamedColors()
imageData = None
# Verify input arguments
if len(argv) > 1:
# Read the image
readerFactory = vtk.vtkImageReader2Factory()
imageReader = readerFactory.CreateImageReader2(argv[1])
imageReader.SetFileName(argv[1])
imageReader.Update()
imageData = imageReader.GetOutput()
else:
drawColor1 = 4 * [255]
drawColor2 = 4 * [255]
drawColor3 = 4 * [255]
color1 = colors.GetColor3ub("warm_grey")
color2 = colors.GetColor3ub("DarkCyan")
color3 = colors.GetColor3ub("LightCoral")
for i in range(3):
drawColor1[i] = color1[i]
drawColor2[i] = color2[i]
drawColor3[i] = color3[i]
canvasSource = vtk.vtkImageCanvasSource2D()
canvasSource.SetExtent(0, 100, 0, 100, 0, 0)
canvasSource.SetScalarTypeToUnsignedChar()
canvasSource.SetNumberOfScalarComponents(3)
canvasSource.SetDrawColor(drawColor1)
canvasSource.FillBox(0, 100, 0, 100)
canvasSource.SetDrawColor(drawColor2)
canvasSource.FillTriangle(10, 10, 25, 10, 25, 25)
canvasSource.SetDrawColor(drawColor3)
canvasSource.FillTube(75, 75, 0, 75, 5.0)
canvasSource.Update()
imageData = canvasSource.GetOutput()
# Create an image actor to display the image
imageActor = vtk.vtkImageActor()
imageActor.SetInputData(imageData)
# Create a renderer to display the image in the background
backgroundRenderer = vtk.vtkRenderer()
# Create a superquadric
superquadricSource = vtk.vtkSuperquadricSource()
superquadricSource.SetPhiRoundness(1.1)
superquadricSource.SetThetaRoundness(.2)
# Create a mapper and actor
superquadricMapper = vtk.vtkPolyDataMapper()
superquadricMapper.SetInputConnection(superquadricSource.GetOutputPort())
superquadricActor = vtk.vtkActor()
superquadricActor.SetMapper(superquadricMapper)
superquadricActor.GetProperty().SetColor(colors.GetColor3d("NavajoWhite"))
sceneRenderer = vtk.vtkRenderer()
renderWindow = vtk.vtkRenderWindow()
# Set up the render window and renderers such that there is
# a background layer and a foreground layer
backgroundRenderer.SetLayer(0)
backgroundRenderer.InteractiveOff()
sceneRenderer.SetLayer(1)
renderWindow.SetNumberOfLayers(2)
renderWindow.AddRenderer(backgroundRenderer)
renderWindow.AddRenderer(sceneRenderer)
renderWindow.SetWindowName("BackgroundImage")
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
renderWindowInteractor.SetRenderWindow(renderWindow)
# Add actors to the renderers
sceneRenderer.AddActor(superquadricActor)
backgroundRenderer.AddActor(imageActor)
# Render once to figure out where the background camera will be
renderWindow.Render()
# Set up the background camera to fill the renderer with the image
origin = imageData.GetOrigin()
spacing = imageData.GetSpacing()
extent = imageData.GetExtent()
camera = backgroundRenderer.GetActiveCamera()
camera.ParallelProjectionOn()
xc = origin[0] + 0.5 * (extent[0] + extent[1]) * spacing[0]
yc = origin[1] + 0.5 * (extent[2] + extent[3]) * spacing[1]
yd = (extent[3] - extent[2] + 1) * spacing[1]
d = camera.GetDistance()
camera.SetParallelScale(0.5 * yd)
camera.SetFocalPoint(xc, yc, 0.0)
camera.SetPosition(xc, yc, d)
# Render again to set the correct view
renderWindow.Render()
# Interact with the window
renderWindowInteractor.Start()
#!/usr/bin/env python import vtk from vtk.test import Testing from vtk.util.misc import vtkGetDataRoot VTK_DATA_ROOT = vtkGetDataRoot() # Create renderer stuff # ren1 = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren1) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # Pipeline stuff # torus = vtk.vtkSuperquadricSource() torus.SetCenter(0.0, 0.0, 0.0) torus.SetScale(1.0, 1.0, 1.0) torus.SetPhiResolution(64) torus.SetThetaResolution(64) torus.SetPhiRoundness(1.0) torus.SetThetaRoundness(1.0) torus.SetThickness(0.5) torus.SetSize(0.5) torus.SetToroidal(1) # The quadric is made of strips, so pass it through a triangle filter as # the curvature filter only operates on polys tri = vtk.vtkTriangleFilter() tri.SetInputConnection(torus.GetOutputPort()) # The quadric has nasty discontinuities from the way the edges are generated # so let's pass it though a CleanPolyDataFilter and merge any points which
def main(argv):
# Verify input arguments
if len(argv) > 1:
# Read the image
jpeg_reader = vtkJPEGReader()
if not jpeg_reader.CanReadFile(argv[1]):
print("Error reading file %s" % argv[1])
return
jpeg_reader.SetFileName(argv[1])
jpeg_reader.Update()
image_data = jpeg_reader.GetOutput()
else:
canvas_source = vtk.vtkImageCanvasSource2D()
canvas_source.SetExtent(0, 100, 0, 100, 0, 0)
canvas_source.SetScalarTypeToUnsignedChar()
canvas_source.SetNumberOfScalarComponents(3)
canvas_source.SetDrawColor(127, 127, 100)
canvas_source.FillBox(0, 100, 0, 100)
canvas_source.SetDrawColor(100, 255, 255)
canvas_source.FillTriangle(10, 10, 25, 10, 25, 25)
canvas_source.SetDrawColor(255, 100, 255)
canvas_source.FillTube(75, 75, 0, 75, 5.0)
canvas_source.Update()
image_data = canvas_source.GetOutput()
# Create an image actor to display the image
image_actor = vtkImageActor()
if VTK_MAJOR_VERSION <= 5:
image_actor.SetInput(image_data)
else:
image_actor.SetInputData(image_data)
# Create a superquadric
superquadric_source = vtkSuperquadricSource()
superquadric_source.SetPhiRoundness(1.1)
superquadric_source.SetThetaRoundness(.2)
# Create a mapper and actor
superquadric_mapper = vtkPolyDataMapper()
superquadric_mapper.SetInputConnection(superquadric_source.GetOutputPort())
superquadric_actor = vtkActor()
superquadric_actor.SetMapper(superquadric_mapper)
vtk_renderer = vtkRenderer()
vtk_renderer.SetLayer(1)
# Set up the render window and renderers such that there is
# a background layer and a foreground layer
background_renderer = vtkRenderer()
background_renderer.SetLayer(0)
background_renderer.InteractiveOff()
background_renderer.AddActor(image_actor)
render_window = vtkRenderWindow()
render_window.SetNumberOfLayers(2)
render_window.AddRenderer(background_renderer)
render_window.AddRenderer(vtk_renderer)
render_window_interactor = vtkRenderWindowInteractor()
render_window_interactor.SetRenderWindow(render_window)
# Add actors to the renderers
vtk_renderer.AddActor(superquadric_actor)
# Render once to figure out where the background camera will be
render_window.Render()
# Set up the background camera to fill the renderer with the image
origin = image_data.GetOrigin()
spacing = image_data.GetSpacing()
extent = image_data.GetExtent()
camera = background_renderer.GetActiveCamera()
camera.ParallelProjectionOn()
xc = origin[0] + 0.5 * (extent[0] + extent[1]) * spacing[0]
yc = origin[1] + 0.5 * (extent[2] + extent[3]) * spacing[1]
# xd = (extent[1] - extent[0] + 1) * spacing[0]
yd = (extent[3] - extent[2] + 1) * spacing[1]
d = camera.GetDistance()
camera.SetParallelScale(0.5 * yd)
camera.SetFocalPoint(xc, yc, 0.0)
camera.SetPosition(xc, yc, d)
# Render again to set the correct view
render_window.Render()
# Interact with the window
render_window_interactor.Start()
def SetUp(self):
'''
Set up squadViewer
'''
def OnClosing():
self.root.quit()
def SetPhi(squad, win, phi):
squad.SetPhiRoundness(float(phi))
win.Render()
def SetTheta(squad, win, theta):
squad.SetThetaRoundness(float(theta))
win.Render()
def SetThickness(squad, win, thickness):
squad.SetThickness(float(thickness))
win.Render()
def SetTexture(actor, texture, win):
if doTexture.get():
actor.SetTexture(texture)
else:
actor.SetTexture(None)
win.Render()
def SetToroid(squad, scale, win):
squad.SetToroidal(toroid.get())
if toroid.get():
scale.config(state=NORMAL, fg='black')
else:
scale.config(state=DISABLED, fg='gray')
win.Render()
self.root = tkinter.Tk()
self.root.title("superquadric viewer")
# Define what to do when the user explicitly closes a window.
self.root.protocol("WM_DELETE_WINDOW", OnClosing)
# Create render window
self.tkrw = vtkTkRenderWidget(self.root, width=550, height=450)
self.tkrw.BindTkRenderWidget()
renWin = self.tkrw.GetRenderWindow()
# Create parameter sliders
#
prs = tkinter.Scale(self.root, from_=0, to=3.5, res=0.1,
orient=HORIZONTAL, label="phi roundness")
trs = tkinter.Scale(self.root, from_=0, to=3.5, res=0.1,
orient=HORIZONTAL, label="theta roundness")
thicks = tkinter.Scale(self.root, from_=0.01, to=1.0, res=0.01,
orient=HORIZONTAL, label="thickness")
# Create check buttons
#
toroid = tkinter.IntVar()
toroid.set(0)
doTexture = tkinter.IntVar()
doTexture.set(0)
rframe = tkinter.Frame(self.root)
torbut = tkinter.Checkbutton(rframe, text="Toroid", variable=toroid)
texbut = tkinter.Checkbutton(rframe, text="Texture", variable=doTexture)
# Put it all together
#
torbut.pack(padx=10, pady=5, ipadx=20, ipady=5, side=RIGHT, anchor=S)
texbut.pack(padx=10, pady=5, ipadx=20, ipady=5, side=RIGHT, anchor=S)
self.tkrw.grid(sticky=N+E+W+S, columnspan=2)
rframe.grid(sticky=N+E+W+S)
thicks.grid(sticky=N+S+E+W, padx=10, ipady=5, row=1, column=1)
prs.grid(sticky=N+E+W+S, padx=10, ipady=5, row = 2, column = 0)
trs.grid(sticky=N+E+W+S, padx=10, ipady=5, row = 2, column = 1)
tkinter.Pack.propagate(rframe,NO)
prs.set(1.0)
trs.set(0.7)
thicks.set(0.3)
toroid.set(1)
doTexture.set(0)
# Create pipeline
#
squad = vtk.vtkSuperquadricSource()
squad.SetPhiResolution(20)
squad.SetThetaResolution(25)
pnmReader = vtk.vtkPNMReader()
pnmReader.SetFileName(VTK_DATA_ROOT + "/Data/earth.ppm")
atext = vtk.vtkTexture()
atext.SetInputConnection(pnmReader.GetOutputPort())
atext.InterpolateOn()
appendSquads = vtk.vtkAppendPolyData()
appendSquads.AddInputConnection(squad.GetOutputPort())
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(squad.GetOutputPort())
mapper.ScalarVisibilityOff()
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.SetTexture(atext)
actor.GetProperty().SetDiffuseColor(0.5, 0.8, 0.8)
actor.GetProperty().SetAmbient(0.2)
actor.GetProperty().SetAmbientColor(0.2, 0.2, 0.2)
squad.SetPhiRoundness(prs.get())
squad.SetThetaRoundness(trs.get())
squad.SetToroidal(toroid.get())
squad.SetThickness(thicks.get())
squad.SetScale(1, 1, 1)
SetTexture(actor, atext, renWin)
# Create renderer stuff
#
ren = vtk.vtkRenderer()
ren.SetAmbient(1.0, 1.0, 1.0)
renWin.AddRenderer(ren)
# Add the actors to the renderer, set the background and size
#
ren.AddActor(actor)
ren.SetBackground(0.25, 0.2, 0.2)
ren.ResetCamera()
ren.GetActiveCamera().Zoom(1.2)
ren.GetActiveCamera().Elevation(40)
ren.GetActiveCamera().Azimuth(-20)
# Associate the functions with the sliders and check buttons.
#
prs.config(command=partial(SetPhi, squad, self.tkrw))
trs.config(command=partial(SetTheta, squad, self.tkrw))
thicks.config(command=partial(SetThickness,squad, self.tkrw))
torbut.config(command=partial(SetToroid, squad, thicks, self.tkrw))
texbut.config(command=partial(SetTexture, actor, atext, self.tkrw))
#!/usr/bin/env python import vtk from vtk.test import Testing from vtk.util.misc import vtkGetDataRoot VTK_DATA_ROOT = vtkGetDataRoot() # Create renderer stuff # ren1 = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren1) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # Pipeline stuff # torus = vtk.vtkSuperquadricSource() torus.SetCenter(0.0,0.0,0.0) torus.SetScale(1.0,1.0,1.0) torus.SetPhiResolution(64) torus.SetThetaResolution(64) torus.SetPhiRoundness(1.0) torus.SetThetaRoundness(1.0) torus.SetThickness(0.5) torus.SetSize(0.5) torus.SetToroidal(1) # The quadric is made of strips, so pass it through a triangle filter as # the curvature filter only operates on polys tri = vtk.vtkTriangleFilter() tri.SetInputConnection(torus.GetOutputPort()) # The quadric has nasty discontinuities from the way the edges are generated # so let's pass it though a CleanPolyDataFilter and merge any points which
def CurvaturesDemo(self):
# We are going to handle two different sources.
# The first source is a superquadric source.
torus = vtk.vtkSuperquadricSource()
torus.SetCenter(0.0, 0.0, 0.0)
torus.SetScale(1.0, 1.0, 1.0)
torus.SetPhiResolution(64)
torus.SetThetaResolution(64)
torus.SetThetaRoundness(1)
torus.SetThickness(0.5)
torus.SetSize(0.5)
torus.SetToroidal(1)
# Rotate the torus towards the observer (around the x-axis)
torusT = vtk.vtkTransform()
torusT.RotateX(55)
torusTF = vtk.vtkTransformFilter()
torusTF.SetInputConnection(torus.GetOutputPort())
torusTF.SetTransform(torusT)
# The quadric is made of strips, so pass it through a triangle filter as
# the curvature filter only operates on polys
tri = vtk.vtkTriangleFilter()
tri.SetInputConnection(torusTF.GetOutputPort())
# The quadric has nasty discontinuities from the way the edges are generated
# so let's pass it though a CleanPolyDataFilter and merge any points which
# are coincident, or very close
cleaner = vtk.vtkCleanPolyData()
cleaner.SetInputConnection(tri.GetOutputPort())
cleaner.SetTolerance(0.005)
# The next source will be a parametric function
rh = vtk.vtkParametricRandomHills()
rhFnSrc = vtk.vtkParametricFunctionSource()
rhFnSrc.SetParametricFunction(rh)
# Now we have the sources, lets put them into a list.
sources = list()
sources.append(cleaner)
sources.append(cleaner)
sources.append(rhFnSrc)
sources.append(rhFnSrc)
# Colour transfer function.
ctf = vtk.vtkColorTransferFunction()
ctf.SetColorSpaceToDiverging()
ctf.AddRGBPoint(0.0, 0.230, 0.299, 0.754)
ctf.AddRGBPoint(1.0, 0.706, 0.016, 0.150)
cc = list()
for i in range(256):
cc.append(ctf.GetColor(float(i) / 255.0))
# Lookup table.
lut = list()
for idx in range(len(sources)):
lut.append(vtk.vtkLookupTable())
lut[idx].SetNumberOfColors(256)
for i, item in enumerate(cc):
lut[idx].SetTableValue(i, item[0], item[1], item[2], 1.0)
if idx == 0:
lut[idx].SetRange(-10, 10)
if idx == 1:
lut[idx].SetRange(0, 4)
if idx == 2:
lut[idx].SetRange(-1, 1)
if idx == 3:
lut[idx].SetRange(-1, 1)
lut[idx].Build()
curvatures = list()
for idx in range(len(sources)):
curvatures.append(vtk.vtkCurvatures())
if idx % 2 == 0:
curvatures[idx].SetCurvatureTypeToGaussian()
else:
curvatures[idx].SetCurvatureTypeToMean()
renderers = list()
mappers = list()
actors = list()
textmappers = list()
textactors = list()
# Create a common text property.
textProperty = vtk.vtkTextProperty()
textProperty.SetFontSize(10)
textProperty.SetJustificationToCentered()
names = [
'Torus - Gaussian Curvature', 'Torus - Mean Curvature',
'Random Hills - Gaussian Curvature',
'Random Hills - Mean Curvature'
]
# Link the pipeline together.
for idx, item in enumerate(sources):
sources[idx].Update()
curvatures[idx].SetInputConnection(sources[idx].GetOutputPort())
mappers.append(vtk.vtkPolyDataMapper())
mappers[idx].SetInputConnection(curvatures[idx].GetOutputPort())
mappers[idx].SetLookupTable(lut[idx])
mappers[idx].SetUseLookupTableScalarRange(1)
actors.append(vtk.vtkActor())
actors[idx].SetMapper(mappers[idx])
textmappers.append(vtk.vtkTextMapper())
textmappers[idx].SetInput(names[idx])
textmappers[idx].SetTextProperty(textProperty)
textactors.append(vtk.vtkActor2D())
textactors[idx].SetMapper(textmappers[idx])
textactors[idx].SetPosition(150, 16)
renderers.append(vtk.vtkRenderer())
gridDimensions = 2
for idx in range(len(sources)):
if idx < gridDimensions * gridDimensions:
renderers.append(vtk.vtkRenderer)
rendererSize = 300
# Create the RenderWindow
#
renderWindow = vtk.vtkRenderWindow()
renderWindow.SetSize(rendererSize * gridDimensions,
rendererSize * gridDimensions)
# Add and position the renders to the render window.
viewport = list()
for row in range(gridDimensions):
for col in range(gridDimensions):
idx = row * gridDimensions + col
viewport[:] = []
viewport.append(
float(col) * rendererSize /
(gridDimensions * rendererSize))
viewport.append(
float(gridDimensions - (row + 1)) * rendererSize /
(gridDimensions * rendererSize))
viewport.append(
float(col + 1) * rendererSize /
(gridDimensions * rendererSize))
viewport.append(
float(gridDimensions - row) * rendererSize /
(gridDimensions * rendererSize))
if idx > (len(sources) - 1):
continue
renderers[idx].SetViewport(viewport)
renderWindow.AddRenderer(renderers[idx])
renderers[idx].AddActor(actors[idx])
renderers[idx].AddActor(textactors[idx])
renderers[idx].SetBackground(0.4, 0.3, 0.2)
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(renderWindow)
renderWindow.Render()
interactor.Start()
def SetUp(self):
'''
Set up squadViewer
'''
def OnClosing():
self.root.quit()
def SetPhi(squad, win, phi):
squad.SetPhiRoundness(float(phi))
win.Render()
def SetTheta(squad, win, theta):
squad.SetThetaRoundness(float(theta))
win.Render()
def SetThickness(squad, win, thickness):
squad.SetThickness(float(thickness))
win.Render()
def SetTexture(actor, texture, win):
if doTexture.get():
actor.SetTexture(texture)
else:
actor.SetTexture(None)
win.Render()
def SetToroid(squad, scale, win):
squad.SetToroidal(toroid.get())
if toroid.get():
scale.config(state=NORMAL, fg='black')
else:
scale.config(state=DISABLED, fg='gray')
win.Render()
self.root = Tkinter.Tk()
self.root.title("superquadric viewer")
# Define what to do when the user explicitly closes a window.
self.root.protocol("WM_DELETE_WINDOW", OnClosing)
# Create render window
self.tkrw = vtkTkRenderWidget(self.root, width=550, height=450)
self.tkrw.BindTkRenderWidget()
self.renWin = self.tkrw.GetRenderWindow()
# Create parameter sliders
#
prs = Tkinter.Scale(self.root,
from_=0,
to=3.5,
res=0.1,
orient=HORIZONTAL,
label="phi roundness")
trs = Tkinter.Scale(self.root,
from_=0,
to=3.5,
res=0.1,
orient=HORIZONTAL,
label="theta roundness")
thicks = Tkinter.Scale(self.root,
from_=0.01,
to=1.0,
res=0.01,
orient=HORIZONTAL,
label="thickness")
# Create check buttons
#
toroid = Tkinter.IntVar()
toroid.set(0)
doTexture = Tkinter.IntVar()
doTexture.set(0)
rframe = Tkinter.Frame(self.root)
torbut = Tkinter.Checkbutton(rframe, text="Toroid", variable=toroid)
texbut = Tkinter.Checkbutton(rframe,
text="Texture",
variable=doTexture)
# Put it all together
#
torbut.pack(padx=10, pady=5, ipadx=20, ipady=5, side=RIGHT, anchor=S)
texbut.pack(padx=10, pady=5, ipadx=20, ipady=5, side=RIGHT, anchor=S)
self.tkrw.grid(sticky=N + E + W + S, columnspan=2)
rframe.grid(sticky=N + E + W + S)
thicks.grid(sticky=N + S + E + W, padx=10, ipady=5, row=1, column=1)
prs.grid(sticky=N + E + W + S, padx=10, ipady=5, row=2, column=0)
trs.grid(sticky=N + E + W + S, padx=10, ipady=5, row=2, column=1)
Tkinter.Pack.propagate(rframe, NO)
prs.set(1.0)
trs.set(0.7)
thicks.set(0.3)
toroid.set(1)
doTexture.set(0)
# Create pipeline
#
squad = vtk.vtkSuperquadricSource()
squad.SetPhiResolution(20)
squad.SetThetaResolution(25)
pnmReader = vtk.vtkPNMReader()
pnmReader.SetFileName(VTK_DATA_ROOT + "/Data/earth.ppm")
atext = vtk.vtkTexture()
atext.SetInputConnection(pnmReader.GetOutputPort())
atext.InterpolateOn()
appendSquads = vtk.vtkAppendPolyData()
appendSquads.AddInputConnection(squad.GetOutputPort())
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(squad.GetOutputPort())
mapper.ScalarVisibilityOff()
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.SetTexture(atext)
actor.GetProperty().SetDiffuseColor(0.5, 0.8, 0.8)
actor.GetProperty().SetAmbient(0.2)
actor.GetProperty().SetAmbientColor(0.2, 0.2, 0.2)
squad.SetPhiRoundness(prs.get())
squad.SetThetaRoundness(trs.get())
squad.SetToroidal(toroid.get())
squad.SetThickness(thicks.get())
squad.SetScale(1, 1, 1)
SetTexture(actor, atext, self.renWin)
# Create renderer stuff
#
ren = vtk.vtkRenderer()
ren.SetAmbient(1.0, 1.0, 1.0)
self.renWin.AddRenderer(ren)
# Add the actors to the renderer, set the background and size
#
ren.AddActor(actor)
ren.SetBackground(0.25, 0.2, 0.2)
ren.ResetCamera()
ren.GetActiveCamera().Zoom(1.2)
ren.GetActiveCamera().Elevation(40)
ren.GetActiveCamera().Azimuth(-20)
# Associate the functions with the sliders and check buttons.
#
prs.config(command=partial(SetPhi, squad, self.renWin))
trs.config(command=partial(SetTheta, squad, self.renWin))
thicks.config(command=partial(SetThickness, squad, self.renWin))
torbut.config(command=partial(SetToroid, squad, thicks, self.renWin))
texbut.config(command=partial(SetTexture, actor, atext, self.renWin))
